Esercizi Eccezioni C++

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

Esercizio 1: Eccezione di divisione per zero

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

#include <iostream>
#include <stdexcept>

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

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

Esercizio 2: Eccezione per indice fuori limite

Creare una funzione che lancia un'eccezione quando si accede a un indice fuori limite di un array.

#include <iostream>
#include <stdexcept>

int getElement(int* arr, int size, int index) {
    if (index < 0 || index >= size) {
        throw std::out_of_range("Indice fuori limite");
    }
    return arr[index];
}

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

Esercizio 3: Eccezione di allocazione della memoria

Creare una funzione che lancia un'eccezione quando l'allocazione della memoria fallisce.

#include <iostream>
#include <stdexcept>

void* allocateMemory(size_t size) {
    void* ptr = malloc(size);
    if (!ptr) {
        throw std::runtime_error("Allocazione di memoria fallita");
    }
    return ptr;
}

int main() {
    try {
        void* ptr = allocateMemory(1024);
        std::cout << "Memoria allocata con successo" << std::endl;
        free(ptr);
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 4: Eccezione di apertura file

Creare una funzione che lancia un'eccezione quando non riesce ad aprire un file.

#include <iostream>
#include <fstream>
#include <stdexcept>

void apriFile(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        throw std::runtime_error("Impossibile aprire il file");
    }
    std::cout << "File aperto con successo" << std::endl;
}

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

Esercizio 5: Eccezione di tipo non valido

Creare una funzione che lancia un'eccezione quando il tipo di dato non è valido.

#include <iostream>
#include <stdexcept>

int convertiInIntero(const std::string& str) {
    for (char c : str) {
        if (!isdigit(c)) {
            throw std::invalid_argument("Tipo di dato non valido");
        }
    }
    return std::stoi(str);
}

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

Esercizio 6: Eccezione di conversione

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

#include <iostream>
#include <stdexcept>

double convertiInDouble(const std::string& str) {
    try {
        return std::stod(str);
    } catch (const std::invalid_argument&) {
        throw std::runtime_error("Conversione fallita: tipo di dato non valido");
    } catch (const std::out_of_range&) {
        throw std::runtime_error("Conversione fallita: valore fuori range");
    }
}

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

Esercizio 7: Eccezione di file non trovato

Creare una funzione che lancia un'eccezione quando un file non è trovato.

#include <iostream>
#include <fstream>
#include <stdexcept>

void leggiFile(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        throw std::runtime_error("File non trovato");
    }
    std::cout << "File aperto con successo" << std::endl;
    file.close();
}

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

Esercizio 8: Eccezione di valore fuori range

Creare una funzione che lancia un'eccezione quando un valore è fuori dal range consentito.

#include <iostream>
#include <stdexcept>

void verificaRange(int val, int min, int max) {
    if (val < min || val > max) {
        throw std::out_of_range("Valore fuori range");
    }
    std::cout << "Valore accettabile: " << val << std::endl;
}

int main() {
    try {
        verificaRange(10, 1, 20);
        verificaRange(30, 1, 20);
    } catch (const std::exception& e) {
        std::cerr << "Errore: " << e.what() << std::endl;
    }
    return 0;
}

Esercizio 9: Eccezione personalizzata

Creare una funzione che lancia un'eccezione personalizzata.

#include <iostream>
#include <stdexcept>

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

void lanciaEccezionePersonalizzata() {
    throw CustomException("Eccezione personalizzata lanciata");
}

int main() {
    try {
        lanciaEccezionePersonalizzata();
    } catch (const CustomException& e) {
        std::cerr << "Errore: " << e.what()

 << std::endl;
    }
    return 0;
}

Esercizio 10: Eccezione generica

Creare una funzione che lancia un'eccezione generica con un messaggio specifico.

#include <iostream>
#include <stdexcept>

void lanciaEccezioneGenerica() {
    throw std::runtime_error("Eccezione generica lanciata");
}

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