C++ Academy · Lezione

Tipi di eccezione personalizzati

Definire le proprie eccezioni

Tipi di eccezione personalizzati è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Perché utilizzare eccezioni personalizzate?

Definire tipi di eccezione personalizzati permette al codice chiamante di catturare in modo specifico i Suoi errori e di associare all'errore dati specifici del dominio.

Derivare da std::exception

Basi le eccezioni su std::exception o su una sua sottoclasse, così si integreranno con i gestori standard ed esporranno what().

#include <exception>
#include <string>

class ConfigError : public std::exception {
    std::string msg;
public:
    explicit ConfigError(std::string m) : msg(std::move(m)) {}
    const char* what() const noexcept override { return msg.c_str(); }
};

Sollevarla e catturarla

Il tipo si comporta come qualsiasi altra eccezione: lo sollevi e lo catturi per riferimento.

#include <iostream>
#include <exception>
#include <string>

class ConfigError : public std::exception {
    std::string msg;
public:
    explicit ConfigError(std::string m) : msg(std::move(m)) {}
    const char* what() const noexcept override { return msg.c_str(); }
};

int main() {
    try {
        throw ConfigError("missing key");
    } catch (const ConfigError& e) {
        std::cout << e.what() << "\n";
    }
}

Riutilizzare le classi base standard

Spesso può derivare da std::runtime_error o std::logic_error, che conservano già un messaggio: è necessario meno codice ripetitivo.

#include <stdexcept>
#include <string>

class NetworkError : public std::runtime_error {
public:
    explicit NetworkError(const std::string& m) : std::runtime_error(m) {}
};

Allegare dati aggiuntivi

Le eccezioni personalizzate possono contenere campi come un codice di errore o il valore che ha causato l'errore, fornendo ai gestori un contesto più ampio.

#include <stdexcept>
#include <string>

class HttpError : public std::runtime_error {
public:
    int status;
    HttpError(int s, const std::string& m)
        : std::runtime_error(m), status(s) {}
};

Catturare tramite la classe base

Poiché il tipo deriva da std::exception, un gestore generico può comunque catturarlo tramite il riferimento alla classe base.

#include <iostream>
#include <stdexcept>

class HttpError : public std::runtime_error {
public:
    int status;
    HttpError(int s, const std::string& m) : std::runtime_error(m), status(s) {}
};

int main() {
    try {
        throw HttpError(404, "not found");
    } catch (const std::exception& e) {
        std::cout << e.what() << "\n";
    }
}

Creare una gerarchia di eccezioni

Raggruppi gli errori correlati sotto una classe base comune, così il codice chiamante può catturare un'intera famiglia o un singolo tipo specifico.

#include <stdexcept>

struct AppError : std::runtime_error { using std::runtime_error::runtime_error; };
struct DbError  : AppError       { using AppError::AppError; };
struct AuthError: AppError       { using AppError::AppError; };

Mantenere what() noexcept

Sovrascriva what() come const noexcept e restituisca un buffer stabile: non deve mai sollevare eccezioni né restituire un puntatore pendente.

Sollevare per valore

Sollevi gli oggetti eccezione per valore, ad esempio throw HttpError(500, "x");. Il runtime ne gestisce l'archiviazione durante lo svolgimento dello stack.

Documentare ciò che si solleva

Renda i tipi di eccezione della Sua API parte del relativo contratto, così il codice chiamante saprà quali gestori scrivere.

Mantenere la semplicità

La maggior parte dei progetti ha bisogno solo di un numero limitato di tipi di eccezione. Derivare da std::runtime_error copre in modo chiaro la maggior parte dei casi.

Verifica rapida

Verifichi la comprensione delle eccezioni personalizzate.

Riepilogo

Ha imparato a definire tipi di eccezione personalizzati derivando da std::exception o std::runtime_error, ad associare dati aggiuntivi, a creare gerarchie, a mantenere what() noexcept e a sollevare le eccezioni per valore. Mantenga l'insieme ridotto e documentato.

Domande Frequenti

La lezione «Tipi di eccezione personalizzati» è gratuita?

Sì — il testo completo di «Tipi di eccezione personalizzati» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Tipi di eccezione personalizzati»?

Definire le proprie eccezioni Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Tipi di eccezione personalizzati»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy