K) Exceptions

Wyjątki

To komunikat, wartość jakiegoś typu. Do rzucenia służy throw

int main(){
    throw 0;
}

---

TYPY:

zaleca się używanie typów zdefiniowanych w < stdexcept >

1. std:: logic_error Ogólny błąd - naruszono założenie, niezmiennik itp.
2. std:: runtime_error Ogólny błąd - błąd czasu wykonywania (możliwy do wykrycia tylko w czasie wykonywania)
3. std:: invalid_argument Przekazano nieprawidłowy argument
4. std:: domain_error Błąd dziedziny operacji (matematycznie) np. dzielenie przez zero
5. std::lenght_error Przekroczenie maksymalnego dozwolonego rozmiaru czegoś
6. std:: out_of_range Argument poza dopuszczalnym zakresem
7. std:: range_error Przekroczenie zakresu w obliczeniach, np. wynik obliczeń jest poza zakresem docel. typu
8. std:: overflow_error Przepełnienie liczby
9. std:: underflow_error Niedopełnienie liczby

example

#include <stdexcept>

int main()
{
    throw std::runtime_error("Mój pierwszy wyjątek");
}

Obsługa wyjątków

Wyjątek trzeba złapać try żeby wiedzieć co zostało wyrzucone i mieć szanse obsłużyć wyjątek. Kod umieszczamy w bloku try, po którym musi się znajdować co najmniej jedna klauzula catch.

example

#include <iostream>
#include <stdexcept>
 
void func(){ 
//HERE CHANGE  |
//            \ /
throw std::runtime_error("Something wrong"); //1.
//throw std::logic_error("Something wrong" ); //2.
//throw "cos innego"; //3.
//throw 5; //4. 

}

void test(){
    try{
        std::cout << "First\n";
        func();
        std::cout<<"Second\n";
        func();
    }
    catch(std::runtime_error & e){
        std::cout<<"Runtime error: "<<e.what()<<" (but it's ok)" <<'\n';
    }catch( std::exception & e){
        std::cout<<"Different stand. excep."<<e.what()<<std::endl;
        throw; //Rzuć ponownie złapany wątek
    }catch(int){
        std::cout<<"I told not to throw int!\n";
        throw std::logic_error("Unexpected int");
    }catch(...){
        std::cout<<"Not expect, not know exception\n";
        throw std::logic_error("Catched not know exception");
    }
}

int main(){
    try{
        test();
    }catch(std::runtime_error & e){
        std::cout<<"blad wykoaniania programu: "<<e.what()<<std::endl;
    }catch(std::logic_error & e){
        std::cout<<"Blad logiczny programu: "<<e.what()<<std::endl;
    }
}

output

First
Runtime error: Something wrong (but it's ok)

First
Different stand. excep.Something wrong
Blad logiczny programu: Something wrong

First
Not expect, not know exception
Blad logiczny programu: Catch not know exception

First
I told not to throw int!
Blad logiczny programu: Unexpected int 

Gwarancja nierzucania wyjątków

Taką gwarancję znacznie łatwiej "spełnić": służy do tego słowo kluczowe noexcept, wprowadzone w C++11. Możemy go użyć do jawnego określenia, że funkcja nie wyrzuca wyjątków: void funkcja() noexcept{