Esercizi Costruttori Classi C++

Ecco degli esercizi semplici con soluzione per praticare le basi dei costruttori delle classi in C++.

Esercizio 1: Costruttore di default

Creare una classe con un costruttore di default e stampare un messaggio.

#include <iostream>

class Esempio {
public:
    Esempio() {
        std::cout << "Costruttore di default chiamato" << std::endl;
    }
};

int main() {
    Esempio e;
    return 0;
}

Esercizio 2: Costruttore parametrizzato

Creare una classe con un costruttore parametrizzato e stampare i valori passati.

#include <iostream>

class Esempio {
private:
    int x;
    int y;
public:
    Esempio(int a, int b) : x(a), y(b) {
        std::cout << "Costruttore parametrizzato chiamato: x=" << x << ", y=" << y << std::endl;
    }
};

int main() {
    Esempio e(10, 20);
    return 0;
}

Esercizio 3: Costruttore di copia

Creare una classe con un costruttore di copia e stampare i valori copiati.

#include <iostream>

class Esempio {
private:
    int x;
public:
    Esempio(int a) : x(a) {}
    Esempio(const Esempio& e) : x(e.x) {
        std::cout << "Costruttore di copia chiamato: x=" << x << std::endl;
    }
};

int main() {
    Esempio e1(10);
    Esempio e2 = e1;
    return 0;
}

Esercizio 4: Costruttore di movimento

Creare una classe con un costruttore di movimento e stampare i valori spostati.

#include <iostream>

class Esempio {
private:
    int* x;
public:
    Esempio(int a) : x(new int(a)) {}
    Esempio(Esempio&& e) noexcept : x(e.x) {
        e.x = nullptr;
        std::cout << "Costruttore di movimento chiamato" << std::endl;
    }
    ~Esempio() {
        delete x;
    }
};

int main() {
    Esempio e1(10);
    Esempio e2 = std::move(e1);
    return 0;
}

Esercizio 5: Costruttore con lista di inizializzazione

Creare una classe con un costruttore che utilizza una lista di inizializzazione.

#include <iostream>

class Esempio {
private:
    int x;
    int y;
public:
    Esempio(int a, int b) : x(a), y(b) {
        std::cout << "Costruttore con lista di inizializzazione chiamato: x=" << x << ", y=" << y << std::endl;
    }
};

int main() {
    Esempio e(10, 20);
    return 0;
}

Esercizio 6: Costruttore delegato

Creare una classe con un costruttore delegato.

#include <iostream>

class Esempio {
private:
    int x;
    int y;
public:
    Esempio() : Esempio(0, 0) {
        std::cout << "Costruttore di default delegato" << std::endl;
    }

    Esempio(int a, int b) : x(a), y(b) {
        std::cout << "Costruttore parametrizzato chiamato: x=" << x << ", y=" << y << std::endl;
    }
};

int main() {
    Esempio e1;
    Esempio e2(10, 20);
    return 0;
}

Esercizio 7: Costruttore con valori di default

Creare una classe con un costruttore che utilizza valori di default per i parametri.

#include <iostream>

class Esempio {
private:
    int x;
    int y;
public:
    Esempio(int a = 0, int b = 0) : x(a), y(b) {
        std::cout << "Costruttore con valori di default chiamato: x=" << x << ", y=" << y << std::endl;
    }
};

int main() {
    Esempio e1;
    Esempio e2(10, 20);
    return 0;
}

Esercizio 8: Costruttore per inizializzare un array

Creare una classe con un costruttore che inizializza un array di interi.

#include <iostream>

class Array {
private:
    int* arr;
    int size;
public:
    Array(int s) : size(s) {
        arr = new int[size];
        for (int i = 0; i < size; ++i) {
            arr[i] = i;
        }
        std::cout << "Array inizializzato" << std::endl;
    }

    ~Array() {
        delete[] arr;
    }

    void stampa() {
        for (int i = 0; i < size; ++i) {
            std::cout << arr[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    Array arr(5);
    arr.stampa();
    return 0;
}

Esercizio 9: Costruttore con parametri const

Creare una classe con un costruttore che accetta parametri const.

#include <iostream>

class Esempio {
private:
    int x;
public:
    Esempio(const int a) : x(a) {
        std::cout << "Costruttore con parametro const chiamato: x=" << x << std::endl;
    }
};

int main() {
    const int val = 10;
    Esempio e(val);
    return 0;
}

Esercizio 10: Costruttore privato

Creare una classe con un costruttore privato e un metodo statico per creare oggetti.

#include <iostream>

class Singleton {
private:
    int x;
    Singleton(int a) : x(a) {
        std::cout << "Costruttore privato chiamato: x=" << x << std::endl;
    }
public:
    static Singleton crea(int a) {
        return Singleton(a);
    }
};

int main() {
    Singleton s = Singleton::crea(10);
    return 0;
}