Esercizi Eccezioni Classi C++

Ecco degli esercizi semplici con soluzione per praticare la gestione delle eccezioni nelle classi in C++.

Esercizio 1: Eccezione di divisione per zero

Creare una classe che lancia un'eccezione quando si tenta di dividere per zero.

#include <iostream>
#include <stdexcept>

class Divisore {
public:
    double dividi(double a, double b) {
        if (b == 0) {
            throw std::runtime_error("Divisione per zero");
        }
        return a / b;
    }
};

int main() {
    Divisore d;
    try {
        std::cout << d.dividi(10, 2) << std::endl;
        std::cout << d.dividi(10, 0) << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 2: Eccezione personalizzata

Creare una classe che lancia un'eccezione personalizzata.

#include <iostream>
#include <stdexcept>

class MyException : public std::runtime_error {
public:
    MyException(const std::string& message) : std::runtime_error(message) {}
};

class Esempio {
public:
    void lanciaEccezione() {
        throw MyException("Eccezione personalizzata");
    }
};

int main() {
    Esempio e;
    try {
        e.lanciaEccezione();
    } catch (const MyException& ex) {
        std::cerr << "Errore: " << ex.what() << std::endl;
    }
    return 0;
}

Esercizio 3: Eccezione nel costruttore

Creare una classe che lancia un'eccezione nel costruttore.

#include <iostream>
#include <stdexcept>

class Esempio {
public:
    Esempio() {
        throw std::runtime_error("Errore nel costruttore");
    }
};

int main() {
    try {
        Esempio e;
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 4: Eccezione nel distruttore

Creare una classe che lancia un'eccezione nel distruttore (e mostrare perché è sconsigliato).

#include <iostream>
#include <stdexcept>

class Esempio {
public:
    ~Esempio() {
        // Non lanciare eccezioni nel distruttore
        try {
            throw std::runtime_error("Errore nel distruttore");
        } catch (const std::exception& e) {
            std::cerr << "Eccezione nel distruttore catturata: " << e.what() << std::endl;
        }
    }
};

int main() {
    try {
        Esempio e;
        throw std::runtime_error("Eccezione esterna");
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 5: Gestione delle eccezioni in un metodo

Creare una classe che gestisce un'eccezione in un metodo e rilancia l'eccezione.

#include <iostream>
#include <stdexcept>

class Esempio {
public:
    void metodo() {
        try {
            throw std::runtime_error("Errore nel metodo");
        } catch (const std::exception& e) {
            std::cerr << "Eccezione catturata nel metodo: " << e.what() << std::endl;
            throw; // Rilancia l'eccezione
        }
    }
};

int main() {
    Esempio e;
    try {
        e.metodo();
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 6: Eccezione nella gestione della memoria dinamica

Creare una classe che lancia un'eccezione nella gestione della memoria dinamica.

#include <iostream>
#include <stdexcept>

class Esempio {
private:
    int* data;
public:
    Esempio() {
        data = new int[10];
        if (!data) {
            throw std::runtime_error("Allocazione di memoria fallita");
        }
    }
    ~Esempio() {
        delete[] data;
    }
};

int main() {
    try {
        Esempio e;
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 7: Eccezione per indice fuori limite

Creare una classe che lancia un'eccezione quando si accede a un indice fuori limite.

#include <iostream>
#include <stdexcept>

class Array {
private:
    int* data;
    int size;
public:
    Array(int s) : size(s) {
        data = new int[size];
    }
    ~Array() {
        delete[] data;
    }
    int& operator[](int index) {
        if (index < 0 || index >= size) {
            throw std::out_of_range("Indice fuori limite");
        }
        return data[index];
    }
};

int main() {
    try {
        Array arr(5);
        arr[10] = 3;
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 8: Eccezione nella copia di un oggetto

Creare una classe che lancia un'eccezione durante la copia di un oggetto.

#include <iostream>
#include <stdexcept>

class Esempio {
private:
    int* data;
public:
    Esempio() {
        data = new int[10];
    }
    Esempio(const Esempio& other) {
        if (!other.data) {
            throw std::runtime_error("Tentativo di copiare un oggetto non valido");
        }
        data = new int[10];
        std::copy(other.data, other.data + 10, data);
    }
    ~Esempio() {
        delete[] data;
    }
};

int main() {
    try {
        Esempio e1;
        Esempio e2 = e1;
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 9: Eccezione nella conversione di tipo

Creare una classe che lancia un'eccezione durante la conversione di tipo.

#include <iostream>
#include <stdexcept>

class Esempio {
public:
    explicit Esempio(int val) {
        if (val < 0) {
            throw std::invalid_argument("Valore negativo non consentito");
        }
    }
};

int main() {
    try {
        Esempio e(-1);
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 10: Eccezione nella funzione di membro

Creare una classe che lancia un'eccezione in una funzione di membro.

#include <iostream>
#include <stdexcept>

class Esempio {
public:
    void funzione(int val) {
        if (val == 0) {
            throw std::runtime_error("Valore non valido: zero");
        }
    }
};

int main() {
    Esempio e;
    try {
        e.funzione(0);
    } catch (const std::exception& ex) {
        std::cerr << "Errore: " << ex.what() << std::endl;
    }
    return 0;
}