C++ Academy · Lekcja

Niestandardowe typy wyjątków

Definiuj własne wyjątki

Niestandardowe typy wyjątków to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.

Po co tworzyć własne wyjątki

Definiowanie własnych typów wyjątków pozwala wywołującym przechwytywać własne błędy w sposób szczegółowy i przenosić wraz z błędem dane specyficzne dla domeny.

Dziedziczenie po std::exception

Wyjątki należy opierać na std::exception lub jego podklasie, aby integrowały się ze standardowymi procedurami obsługi i udostępniały funkcję 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(); }
};

Zgłaszanie i przechwytywanie

Państwa typ zachowuje się jak każdy inny wyjątek: należy go zgłaszać i przechwytywać przez referencję.

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

Ponowne używanie standardowych klas bazowych

Często można dziedziczyć po std::runtime_error lub std::logic_error, które już przechowują komunikat — oznacza to mniej powtarzalnego kodu.

#include <stdexcept>
#include <string>

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

Przenoszenie dodatkowych danych

Własne wyjątki mogą przechowywać pola, takie jak kod błędu lub problematyczna wartość, zapewniając procedurom obsługi więcej informacji.

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

Przechwytywanie przez klasę bazową

Ponieważ Państwa typ dziedziczy po std::exception, ogólna procedura obsługi nadal przechwyci go za pośrednictwem referencji do klasy bazowej.

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

Tworzenie hierarchii wyjątków

Należy grupować powiązane błędy pod wspólną klasą bazową, aby wywołujący mogli przechwytywać całą rodzinę błędów albo pojedynczy, konkretny 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; };

Zachowaj noexcept dla what()

Funkcję what() należy przesłaniać jako const noexcept i zwracać stabilny bufor — funkcja ta nie może zgłaszać wyjątków ani zwracać wiszącego wskaźnika.

Zgłaszanie przez wartość

Obiekty wyjątków należy zgłaszać przez wartość (np. throw HttpError(500, "x");). Środowisko uruchomieniowe zarządza ich przechowywaniem podczas rozwijania stosu.

Dokumentowanie zgłaszanych wyjątków

Typy wyjątków używane przez API należy traktować jako część jego kontraktu, aby wywołujący wiedzieli, jakie procedury obsługi napisać.

Zachowaj prostotę

Większość projektów potrzebuje zaledwie kilku typów wyjątków. Dziedziczenie po std::runtime_error przejrzyście obejmuje większość przypadków.

Szybkie sprawdzenie

Proszę sprawdzić swoją znajomość własnych wyjątków.

Podsumowanie

Poznali Państwo sposób definiowania własnych typów wyjątków przez dziedziczenie po std::exception lub std::runtime_error, przenoszenia dodatkowych danych, tworzenia hierarchii, zachowywania właściwości noexcept funkcji what() oraz zgłaszania wyjątków przez wartość. Zestaw typów powinien być niewielki i udokumentowany.

Często zadawane pytania

Czy lekcja „Niestandardowe typy wyjątków” jest bezpłatna?

Tak — pełny tekst „Niestandardowe typy wyjątków” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Niestandardowe typy wyjątków”?

Definiuj własne wyjątki Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C++ Academy?

Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Niestandardowe typy wyjątków”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?

Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C++ Academy