Esercizi Costruttori Classi C++
- Esercizio 1: Costruttore di default
- Esercizio 2: Costruttore parametrizzato
- Esercizio 3: Costruttore di copia
- Esercizio 4: Costruttore di movimento
- Esercizio 5: Costruttore con lista di inizializzazione
- Esercizio 6: Costruttore delegato
- Esercizio 7: Costruttore con valori di default
- Esercizio 8: Costruttore per inizializzare un array
- Esercizio 9: Costruttore con parametri const
- Esercizio 10: Costruttore privato
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;}