ARCHIV

C++ výjimky

V tomto článku je vysvětleno zpracování výjimek v jazyce C++. Je tedy popsáno, co to vlastně výjimka je a jak ji lze zachytit. Dále je v článku popsáno, co se stane, když se výjimka nezachytí a nechybí ani krátká zmínka o úniku paměti.

28.2.2011 12:00 | Petr Sklenička | Články autora | přečteno 17106×

Jak již samotný název napovídá, výjimka bude něco, co se nestává příliš často, ale stát se to může. V programování se výjimkou rozumí nějaká neočekávaná událost, která může vést i ke zhroucení samotného programu. Pravděpodobně nejčastějším příkladem, na jakém se začínají vysvětlovat výjimky, je dělení nulou. Dejme tomu, že v našem programu očekáváme od uživatele zadání dvou čísel, které následně chceme mezi sebou vydělit. Když bude vše dle našeho očekávání, uživatel zadá například čísla 6 a 3, program vypočte podíl, vrátí číslo 2 a vše je jak má být. Problém nastane, pokud jako druhé číslo zadá nulu. To je pro nás výjimečná situace, neboť nulou dělit nelze. Proto je třeba tuto možnost ohlídat, aby nedošlo ke zhroucení programu. K tomuto účelu slouží právě výjimky.

Princip výjimek spočivá v tom, že část kódu, ve kterém může nastat výjimka, uzavřeme do bloku try. V případě, že v bloku try dojde k nějaké nečekáné situaci, řízení programu se předá do bloku catch a provedou se příkazy, umístěné v tomto bloku. Pokud k žádné výjimce nedojde, program bude pokračovat normálně dál s tím, že blok catch se přeskočí. Základní syntaxe v C++ tedy vypadá takto:

try
{
  // Nejaky kod, ktery muze zpusobit vyjimku
}
catch (Typ vyjimky)
{
  // Kod, ktery se provede pri vyvolani vyjimky
}

int main()
{
  double a, b;
  cin >> a;
  cin >> b;

  try
  {
    if (b == 0)
      throw "Deleni nulou.\n";
    cout << a / b << endl;
  }
  catch (const char* exception)
  {
    cout << "Byla zachycena vyjimka - " << exception;
  }
  return 0;
}

Vzhledem k tomu, že v programu většinou může dojít k více výjimkám, je možné napsat více bloků catch, přičemž každý bude mít na starost konkrétní typ výjimky. Jeden bude například hlídat zápis za konec pole, druhý připojení k internetu, třetí bude mít na starost chování jaderného reaktoru atd... Existuje však blok catch, který dokáže zachytit všechny výjimky.

try
{
  NejakaNebezpecnaFunkce();
}
catch (...)
{
  // Timto blokem je mozne chytit kazdou vyjimku
}

Výjimky mohou být také součástí tříd. Můžeme tedy vytvořit jiný typ objektu pro různé výjimky, které budeme chtít zachytit, přičemž samotný objekt může nést informace, týkající se vzniklého problému. Jestliže se výjimka, kterou chceme odchytit, vztahuje na něco, co se děje v nějaké třídě, bývá vhodné definovat typ výjimky jako vnořenou třídu. Pro jednoduchost můžeme uvažovat, že máme třídu MyStructure, v níž máme veřejně deklarovanou třídu WrongIndex. Třída MyStructure bude nějakým způsobem pracovat s polem (je vcelku nepodstatné, jakým způsobem). Jestliže zadáme špatnou hodnotu indexu, můžeme vyvolat výjimku, která bude typu WrongIndex. Blok catch(který se mimochodem často označuje jako handler) by vypadal následovně:

catch (MyStructure::WrongIndex&)
{
  // neco...
}

Co se stane, když se výjimka nezachytí

Jak jsem již výše psal, nastane-li v programu něco neočekávaného, často tato situace vede k ukončení programu. Podívejme se na to ale trochu podrobněji. Nezachycená výjimka totiž nezpůsobí okamžité ukončení programu. Místo toho nejprve v programu dojde k zavolání funkce terminate(), přičemž tato funkce volá funkci abort(). Toto standardní chování je však možné v programu upravit, a to díky funkci set_terminate(). Deklaraci obou těchto funkcí (terminate() a set_terminate() je možné najit v hlavičkovém souboru exception. Budeme-li tedy chtít změnit chování programu při nezachycené výjimce, můžeme to provést takto:

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

void myFunction()
{
  cerr << "Nezachycena vyjimka.\n";
  cerr << "Program bude ukoncen.\n";
  exit(1);
}

int main()
{
  set_terminate(myFunction);
  int a, b, c;
  cin >> a >> b;
  if (b == 0) throw "Nezachycena vyjimka";
  c = a / b;
  cout << c;
  return 0;
}

Únik paměti

Nyní již víme, k čemu výjimky slouží a jak se používají. Nicméně tak jako všechno ostatní, tak i výjimky mají své nevýhody. S jejich použitím se zvětšuje velikost výsledného programu a program se stává o něco pomalejším. Výjimky si také příliš dobře nerozumí se šablonami, neboť šablony funkcí mohou vyvolávat různé výjimky v závislosti na konkrétní specializaci. Někdy také může nastat problém s dynamickou alokací paměti. V následující ukázce pochopíte, o čem mluvím.

try
{
    p = new int [100];
    if (myFunction() == false)
      throw "Nejaka vyjimka";
    /*
      Nejaky dalsi kod
    */
  delete [] p;
}

int *p = new int [100];
try
{
  if (myFunction() == false)
    throw "Nejaka vyjimka";

    delete [] p;
    cout << "Pamet uvolnena.\n";
  }
  catch (const char *ex)
  {
    delete [] p;
    cerr << "Vyjimka zachycena.\nPamet uvolnena.\n";
  }

Verze pro tisk

DISKUZE Výjimky a dělení nulou 3.3.2011 15:08 Miloslav Ponkrác Re: Výjimky a dělení nulou 4.3.2011 19:47 Aleš Hakl   Re: Výjimky a dělení nulou 5.3.2011 12:07 Miloslav Ponkrác 2x uvolněná paměť 3.3.2011 18:29 Jaroslav Šmíd   Re: 2x uvolněná paměť 3.3.2011 22:26 Miloslav Ponkrác Zobrazit označené Zobrazit vše Příspívat do diskuze mohou pouze registrovaní uživatelé.