Esercizi Operatori Conversione C++
- Esercizio 1: Conversione implicita con costruttore
- Esercizio 2: Conversione implicita con operatore di conversione
- Esercizio 3: Conversione esplicita con operatore di conversione
- Esercizio 4: Conversione implicita tra classi
- Esercizio 5: Conversione esplicita tra classi
- Esercizio 6: Conversione con puntatori
- Esercizio 7: Conversione a stringa
- Esercizio 8: Conversione a tipo personalizzato
Ecco degli esercizi semplici con soluzione per praticare l’utilizzo degli operatori di conversione in C++.
Esercizio 1: Conversione implicita con costruttore
Creare una classe che permette la conversione implicita da un tipo base con un costruttore.
#include <iostream>
class MyClass {private: int valore;public: MyClass(int v) : valore(v) {} void stampa() const { std::cout << "Valore: " << valore << std::endl; }};
int main() { MyClass obj = 42; // Conversione implicita obj.stampa(); return 0;}
Esercizio 2: Conversione implicita con operatore di conversione
Creare una classe che permette la conversione implicita a un tipo base con un operatore di conversione.
#include <iostream>
class MyClass {private: int valore;public: MyClass(int v) : valore(v) {} operator int() const { return valore; }};
int main() { MyClass obj(42); int val = obj; // Conversione implicita std::cout << "Valore: " << val << std::endl; return 0;}
Esercizio 3: Conversione esplicita con operatore di conversione
Creare una classe che permette la conversione esplicita a un tipo base con un operatore di conversione esplicita.
#include <iostream>
class MyClass {private: int valore;public: MyClass(int v) : valore(v) {} explicit operator int() const { return valore; }};
int main() { MyClass obj(42); int val = static_cast<int>(obj); // Conversione esplicita std::cout << "Valore: " << val << std::endl; return 0;}
Esercizio 4: Conversione implicita tra classi
Creare due classi che permettono la conversione implicita tra loro con costruttori di conversione.
#include <iostream>
class ClassB;
class ClassA {private: int valore;public: ClassA(int v) : valore(v) {} ClassA(const ClassB& b); void stampa() const { std::cout << "ClassA Valore: " << valore << std::endl; }};
class ClassB {private: int valore;public: ClassB(int v) : valore(v) {} operator ClassA() const { return ClassA(valore); } void stampa() const { std::cout << "ClassB Valore: " << valore << std::endl; }};
ClassA::ClassA(const ClassB& b) : valore(b.valore) {}
int main() { ClassA a = 42; ClassB b = a; // Conversione implicita b.stampa(); a = b; // Conversione implicita a.stampa(); return 0;}
Esercizio 5: Conversione esplicita tra classi
Creare due classi che permettono la conversione esplicita tra loro con costruttori di conversione espliciti.
#include <iostream>
class ClassB;
class ClassA {private: int valore;public: explicit ClassA(int v) : valore(v) {} explicit ClassA(const ClassB& b); void stampa() const { std::cout << "ClassA Valore: " << valore << std::endl; }};
class ClassB {private: int valore;public: explicit ClassB(int v) : valore(v) {} explicit operator ClassA() const { return ClassA(valore); } void stampa() const { std::cout << "ClassB Valore: " << valore << std::endl; }};
ClassA::ClassA(const ClassB& b) : valore(b.valore) {}
int main() { ClassA a(42); ClassB b = static_cast<ClassB>(a); // Conversione esplicita b.stampa(); a = static_cast<ClassA>(b); // Conversione esplicita a.stampa(); return 0;}
Esercizio 6: Conversione con puntatori
Creare una classe che permette la conversione a un puntatore con un operatore di conversione.
#include <iostream>
class MyClass {private: int valore;public: MyClass(int v) : valore(v) {} operator int*() { return &valore; }};
int main() { MyClass obj(42); int* ptr = obj; // Conversione implicita std::cout << "Valore puntato: " << *ptr << std::endl; return 0;}
Esercizio 7: Conversione a stringa
Creare una classe che permette la conversione a una stringa con un operatore di conversione.
#include <iostream>#include <string>
class MyClass {private: int valore;public: MyClass(int v) : valore(v) {} operator std::string() const { return std::to_string(valore); }};
int main() { MyClass obj(42); std::string str = obj; // Conversione implicita std::cout << "Valore come stringa: " << str << std::endl; return 0;}
Esercizio 8: Conversione a tipo personalizzato
Creare una classe che permette la conversione a un tipo personalizzato con un operatore di conversione.
#include <iostream>
class CustomType {private: int valore;public: CustomType(int v) : valore(v) {} void stampa() const { std::cout << "CustomType Valore: " << valore << std::endl; }};
class MyClass {private: int valore;public: MyClass(int v) : valore(v) {} operator CustomType() const { return CustomType(valore); }};
int main() { MyClass obj(42); CustomType ct = obj; // Conversione implicita ct.stampa(); return 0;}