Lidsky řečeno
Výjimka je jako požární alarm. Když se v místnosti něco pokazí, nemusíš to řešit hned na místě: zmáčkneš alarm a událost se předá výš, někomu, kdo ví, co dělat (hasiči, vrátný, ředitel). Cestou ven se ale všichni musí slušně vyklidit (uvolnit své věci), a o to se v C++ starají destruktory. Soubor je zase sešit v šuplíku: musíš ho otevřít, přečíst nebo psát a zavřít. A také ověřit, že v šuplíku opravdu je.
Obtížnost: 3 z 5.
throw, try a catch
Výjimku vyhodíš příkazem throw. Kdo ji chce zachytit, obalí kód blokem try a za ním dá catch. Pokud nastane výjimka, zbytek try se přeskočí a řízení skočí do catch.
#include <iostream>
#include <stdexcept>
int divide(int a, int b) {
if (b == 0) throw std::invalid_argument("division by zero");
return a / b;
}
int main() {
try {
std::cout << divide(8, 2) << "\n";
std::cout << divide(1, 0) << "\n";
std::cout << "not reached\n";
} catch (const std::exception& e) {
std::cout << "error: " << e.what() << "\n";
}
std::cout << "done\n";
}4
error: division by zero
donePrvní volání vrátí 4. Druhé vyhodí výjimku, takže se třetí řádek v try (not reached) nikdy neprovede a řízení skočí do catch. Metoda what() vrátí text. Po bloku catch program normálně pokračuje a vypíše done.
Vždy se zachytává referencí na konstantu: const std::exception& e. Kdybys chytal hodnotou, výjimka by se při kopii „ořízla“ (slicing, jako v lekci o dědičnosti).
Co vypíše try a catch?
Standardní výjimky
Všechny standardní výjimky dědí od std::exception (hlavička <exception>, hierarchie v <stdexcept>):
| Třída | Kdy |
|---|---|
std::invalid_argument | funkce dostala nesmyslný argument |
std::out_of_range | index nebo klíč mimo rozsah (vector::at) |
std::runtime_error | obecná chyba za běhu |
std::bad_alloc | nedostatek paměti u new |
std::logic_error | chyba v logice programu |
Vlastní výjimku napíšeš jako třídu odvozenou od std::runtime_error nebo std::exception. Pozor na typické chyby: nepoužívej výjimky pro běžné řízení toku (například pro konec cyklu) a neházej jako výjimku int nebo const char*.
Úklid při vyhození výjimky
Když výjimka letí z funkce ven, C++ zavolá destruktory všech lokálních objektů, které přitom zanikají. Tomu se říká odvíjení zásobníku (stack unwinding). Díky tomu funguje RAII: zdroje se uvolní i při chybě.
#include <iostream>
#include <stdexcept>
struct Guard {
~Guard() { std::cout << "cleanup\n"; }
};
void f() {
Guard g;
throw std::runtime_error("boom");
}
int main() {
try {
f();
} catch (const std::runtime_error& e) {
std::cout << e.what() << "\n";
}
}cleanup
boomNejdřív se při opuštění f zničí g (vypíše cleanup) a teprve potom se provede catch s textem boom. Pořadí je důležité: úklid předchází zachycení.
Pořadí úklidu
Úskalí: pořadí bloků catch
Bloky catch se zkoušejí shora dolů a použije se první, který sedí. Protože std::out_of_range je std::exception, musí být konkrétnější typ nahoře.
#include <iostream>
#include <stdexcept>
int main() {
try {
throw std::out_of_range("x");
} catch (const std::exception&) {
std::cout << "exception\n";
} catch (const std::out_of_range&) {
std::cout << "out_of_range\n";
}
}exceptionObecnější catch je první a chytí vše, druhý blok se nikdy nepoužije. Překladače na to varují (-Wall). Správně je opačné pořadí: nejdřív out_of_range, pak exception. Univerzální catch (...) (chytí cokoli) patří úplně na konec.
Soubory: fstream
Pro práci se soubory jsou v <fstream> třídy std::ofstream (zápis) a std::ifstream (čtení). Používají se stejně jako cout a cin: operátory << a >>, funkce std::getline.
#include <fstream>
#include <iostream>
#include <string>
int main() {
{
std::ofstream out("notes.txt");
out << "red\n" << "green\n" << "blue\n";
}
std::ifstream in("notes.txt");
if (!in) {
std::cout << "cannot open\n";
return 1;
}
std::string line;
int n = 0;
while (std::getline(in, line)) {
++n;
std::cout << n << ": " << line << "\n";
}
}1: red
2: green
3: blueProgram (za předpokladu, že se smí zapisovat do aktuální složky) napíše tři řádky do souboru notes.txt a pak je přečte a očísluje. Vnitřní blok kolem ofstream zavře soubor při zániku objektu (RAII), takže se data zapíšou dřív, než je čtení potřebuje. std::getline vrátí false, když už není co číst, proto se používá přímo v podmínce while.
Co vypíše čtení souboru?
Důležité: proudy souborů nevyhazují výjimky automaticky. Neotevřený nebo neexistující soubor se projeví jen tím, že proud je ve „špatném stavu“, a to musíš zkontrolovat (if (!in)). Další užitečné režimy: std::ios::app (přidávat na konec), std::ios::binary (binárně). Pro práci s cestami, složkami a velikostmi souborů je od C++17 v <filesystem>.
Vyber správně
Spoj pojem s významem
Ke každému pojmu najdi popis.
Výjimka, nebo kontrola?
Roztřiď, jak se daná chyba v C++ obvykle řeší.
Co udělá throw uprostřed bloku try?
Pokud se nenajde vhodný catch, zavolá se nakonec std::terminate a program skončí.
Co je špatně? try { ... } catch (const std::exception&) { ... } catch (const std::out_of_range&) { ... }
std::out_of_range dědí od std::exception. Konkrétnější typ musí být nahoře.
Co se stane, když otevřeš neexistující soubor přes std::ifstream in("nope.txt");?
Proudy souborů výchozím nastavením nevyhazují výjimky, stav kontroluješ sám.
Proč ofstream ve vnitřním bloku zajistí, že se data zapíšou před čtením?
Destruktor proudu soubor zavře (RAII). Můžeš také zavolat out.close().
Pod kapotou · noexcept, cena výjimek a alternativy
Funkci, která nikdy nevyhodí výjimku, označíš noexcept (překladač s tím může lépe optimalizovat, a když přesto vyhodí, zavolá se std::terminate). Moderní překladače mají tzv. zero-cost model: když výjimka nenastane, try nic nestojí, ale samotné vyhození je pomalé (řádově mikrosekundy). Proto se výjimky nehodí pro očekávané situace. V C++23 přibyl std::expected<T, E> (hlavička <expected>), který vrací buď hodnotu, nebo chybu bez vyhození výjimky. V C++17 je std::optional. Některé projekty (herní vývoj, vestavěná zařízení) výjimky vypínají (-fno-exceptions). Pro soubory a cesty v C++17 slouží std::filesystem, která při chybách umí vyhazovat std::filesystem::filesystem_error.