Gestione delle Eccezioni in C++

Ciao a tutti, aspiranti programmatori! Oggi intraprenderemo un viaggio avventuroso nel mondo della Gestione delle Eccezioni in C++. Come insegnante di informatica amichevole della vostra zona, sono qui per guidarvi attraverso questo argomento importante. Quindi, prenda la sua bevanda preferita, si rilassi e... immergiamoci!

C++ Exception Handling

Cos'è un'Eccezione?

Prima di iniziare a lanciare e catturare eccezioni come giocolieri esperti, capiamo cosa sono. Nel mondo della programmazione, le eccezioni sono eventi inaspettati che si verificano durante l'esecuzione di un programma. Sono come quegli esami a sorpresa che usavo dare (scusate per questo!) – inaspettati e a volte un po' difficile da gestire.

Le eccezioni interrompono il flusso normale delle istruzioni di un programma. Possono essere causate da vari fattori, come:

Divisione per zero
Accesso a un array fuori dai limiti
Esaurimento della memoria
Tentativo di aprire un file che non esiste

Ora, vediamo come C++ ci permette di gestire queste situazioni inaspettate con grazia.

Lancio delle Eccezioni

Gli Elementi di Base del Lancio

In C++, utilizziamo la parola chiave throw per sollevare un'eccezione. È come alzare la mano in classe quando hai una domanda o un problema. Ecco un esempio semplice:

#include <iostream>
using namespace std;

int main() {
try {
throw 20;
}
catch (int e) {
cout << "È_occorsa un'eccezione. Eccezione Nr. " << e << endl;
}
return 0;
}

In questo esempio, stiamo lanciando un'eccezione intera con il valore 20. Ma non preoccuparsi, la cattureremo tra un momento!

Lancio di Tipi Diversi di Eccezioni

C++ è flessibile e permette di lanciare eccezioni di vari tipi. Vediamo un esempio più pratico:

#include <iostream>
#include <stdexcept>
using namespace std;

double divide(int a, int b) {
if (b == 0) {
throw runtime_error("Divisione per zero!");
}
return static_cast<double>(a) / b;
}

int main() {
try {
cout << divide(10, 2) << endl;  // Questo funzionerà bene
cout << divide(10, 0) << endl;  // Questo lancerà un'eccezione
}
catch (const runtime_error& e) {
cout << "Eccezione catturata: " << e.what() << endl;
}
return 0;
}

In questo esempio, stiamo lanciando un'eccezione runtime_error quando qualcuno tenta di dividere per zero. È come mettere un cartello "No Divisione per Zero" nella nostra zona matematica!

Cattura delle Eccezioni

Gli Elementi di Base della Cattura

Ora che sappiamo come lanciare eccezioni, impariamo come catturarle. Catturare le eccezioni è come essere un proprietario di animali domestici responsabile – devi essere pronto a gestire qualunque cosa il tuo codice ti lancia!

Utilizziamo un blocco try-catch per catturare le eccezioni. Il blocco try contiene il codice che potrebbe lanciare un'eccezione, e il blocco catch gestisce l'eccezione se questa si verifica.

#include <iostream>
using namespace std;

int main() {
try {
int age = -5;
if (age < 0) {
throw "L'età non può essere negativa!";
}
cout << "L'età è: " << age << endl;
}
catch (const char* msg) {
cerr << "Errore: " << msg << endl;
}
return 0;
}

In questo esempio, stiamo controllando se l'età è negativa. Se lo è, lanciamo un'eccezione con un messaggio di errore personalizzato.

Cattura di Eccezioni Multiple

A volte, diversi tipi di eccezioni possono essere lanciate dallo stesso pezzo di codice. In questi casi, possiamo avere più blocchi catch:

#include <iostream>
#include <stdexcept>
using namespace std;

int main() {
try {
int choice;
cout << "Inserisci 1 per eccezione intera, 2 per errore di runtime: ";
cin >> choice;

if (choice == 1) {
throw 42;
} else if (choice == 2) {
throw runtime_error("È apparso un errore di runtime selvaggio!");
} else {
throw "Scelta sconosciuta!";
}
}
catch (int e) {
cout << "Eccezione intera catturata: " << e << endl;
}
catch (const runtime_error& e) {
cout << "Errore di runtime catturato: " << e.what() << endl;
}
catch (...) {
cout << "È stata catturata un'eccezione sconosciuta!" << endl;
}
return 0;
}

Questo esempio mostra come possiamo catturare diversi tipi di eccezioni. Il blocco catch (...) è un blocco catch-all che gestirà qualsiasi eccezione non catturata dai blocchi catch precedenti. È come avere una rete di sicurezza per tutte quelle sorprese inaspettate!

Eccezioni Standard di C++

C++ viene con una serie di eccezioni standard che puoi utilizzare nei tuoi programmi. Queste sono come leArmy knives svizzere del mondo delle eccezioni – versatili e sempre pronte ad aiutare!

Ecco una tabella di alcune eccezioni standard comunemente utilizzate:

Eccezione	Descrizione
std::runtime_error	Errori di logica di runtime
std::logic_error	Errori di logica
std::out_of_range	Accesso oltre l'intervallo
std::overflow_error	Sovraccarico aritmetico
std::bad_alloc	Fallimento dell'allocazione della memoria

Vediamo un esempio che utilizza un'eccezione standard:

#include <iostream>
#include <vector>
#include <stdexcept>
using namespace std;

int main() {
vector<int> numbers = {1, 2, 3, 4, 5};
try {
cout << numbers.at(10) << endl;  // Questo lancerà un'eccezione out_of_range
}
catch (const out_of_range& e) {
cerr << "Errore di fuori intervallo: " << e.what() << endl;
}
return 0;
}

In questo esempio, stiamo cercando di accedere a un elemento fuori dall'intervallo del nostro vettore. La funzione at() lancia un'eccezione out_of_range quando questo accade.

Definizione di Nuove Eccezioni

Mentre le eccezioni standard sono grandi, a volte hai bisogno di qualcosa di più adattato alle tue esigenze specifiche. Ecco dove vengono in handy le eccezioni personalizzate!

Ecco come puoi definire la tua classe di eccezione personalizzata:

#include <iostream>
#include <exception>
using namespace std;

class NegativeValueException : public exception {
public:
const char* what() const throw() {
return "I valori negativi non sono ammessi!";
}
};

double squareRoot(double x) {
if (x < 0) {
throw NegativeValueException();
}
return sqrt(x);
}

int main() {
try {
cout << squareRoot(25) << endl;  // Questo funzionerà bene
cout << squareRoot(-5) << endl;  // Questo lancerà la nostra eccezione personalizzata
}
catch (const NegativeValueException& e) {
cerr << "Errore: " << e.what() << endl;
}
return 0;
}

In questo esempio, abbiamo creato una classe personalizzata NegativeValueException. La utilizziamo nella nostra funzione squareRoot per lanciare un'eccezione quando qualcuno tenta di calcolare la radice quadrata di un numero negativo.

E con questo, ragazzi, abbiamo coperto gli elementi di base della Gestione delle Eccezioni in C++. Ricorda, le eccezioni sono i tuoi amici. Ti aiutano a scrivere codice più robusto e resistente agli errori. Continua a praticare, e presto sarai in grado di gestire le eccezioni come un professionista!

Buon coding, e che le tue eccezioni siano sempre catturate!

Credits: Image by storyset