C++ Academy · Lektion

Egna undantagstyper

Definiera egna undantag

Lektion 4 av 413 steg

Egna undantagstyper är en gratis lektion i C++ Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för C++ Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C++ Academy innehåller totalt 4 lektioner.

Varför egna undantag?

Genom att definiera egna undantagstyper kan anropare fånga era fel specifikt och bära med domänspecifika data tillsammans med felet.

Härled från std::exception

Basera era undantag på std::exception eller en underklass, så integreras de med standardhanterare och tillhandahåller 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(); }
};

Kasta och fånga det

Er typ fungerar som vilket annat undantag som helst: kasta den och fånga den med referens.

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

Återanvänd standardbasklasser

Ofta kan ni härleda från std::runtime_error eller std::logic_error, som redan lagrar ett meddelande – mindre standardkod behövs.

#include <stdexcept>
#include <string>

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

Lagra extra data

Egna undantag kan innehålla fält som en felkod eller det felaktiga värdet, vilket ger hanterare mer sammanhang.

#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) {}
};

Fånga med basklassen

Eftersom er typ härstammar från std::exception kan en generell hanterare fortfarande fånga den via basreferensen.

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

Bygg en undantagshierarki

Gruppera relaterade fel under en gemensam basklass, så att anropare kan fånga en hel familj eller en enda specifik typ.

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

Låt what() vara noexcept

Åsidosätt what() som const noexcept och returnera en stabil buffert – metoden får aldrig kasta eller returnera en hängande pekare.

Kasta efter värde

Kasta undantagsobjekt efter värde (till exempel throw HttpError(500, "x");). Körmiljön hanterar deras lagring under stackavvecklingen.

Dokumentera vad ni kastar

Gör API:ets undantagstyper till en del av dess kontrakt, så att anropare vet vilka fångster de ska skriva.

Håll det enkelt

De flesta projekt behöver bara ett litet antal undantagstyper. Att härleda från std::runtime_error täcker majoriteten av fallen på ett tydligt sätt.

Snabbtest

Testa er förståelse av egna undantag.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er att definiera egna undantagstyper genom att härleda från std::exception eller std::runtime_error, bära med extra data, bygga hierarkier, låta what() vara noexcept och kasta efter värde. Håll uppsättningen liten och dokumenterad.

Gratis att börja

Lär dig C++ med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Egna undantagstyper” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen C++ Academy, inklusive ”Egna undantagstyper”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i C++ Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Egna undantagstyper”?

Definiera egna undantag Ni övar på C++ Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C++ Academy?

Du behöver inga förkunskaper. Utbildningen i C++ Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Egna undantagstyper”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C++ Academy-lektionen?

Ja. Varje C++ Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C++ Academy