Esercizi Operatori Conversione C++

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;
}