
---------------
template<typename T>
class initializer_list { // iso.18.9
public:
    using value_type = T;
    using reference = const T&; // zwr uwag na const: elementy initializer_list s niezmienne
    using const_reference = const T&;
    using size_type = size_t;
    using iterator = const T*;
    using const_iterator = const T*;

    initializer_list() noexcept;

    size_t size() const noexcept;     // liczba elementw
    const T* begin() const noexcept;  // pierwszy element
    const T* end() const noexcept;    // miejsce za ostatnim elementem
};

template<typename T>
    const T* begin(initializer_list<T> lst) noexcept { return lst.begin(); }
template<typename T>
    const T* end(initializer_list<T> lst) noexcept { return lst.end(); }
---------------
void f(initializer_list<int> lst)
{
    for(int i=0; i<lst.size(); ++i)
        cout << lst[i] << '\n'; // bd

    const int* p = lst.begin();
    for(int i=0; i<lst.size(); ++i)
        cout << p[i] << '\n';   // OK
}
---------------
void f2(initializer_list<int> lst)
{
    for (auto x : lst)
        cout << x << '\n';
}

---------------
class exception {
public:
    exception();
    exception(const exception&);
    exception& operator=(const exception&);
    virtual ~exception();
    virtual const char* what() const;
};
---------------
struct My_error : runtime_error {
    My_error(int x) :runtime_error{"My_error"}, interesting_value{x} { }
    int interesting_value;
};
---------------
int main()
try{
    //...
}

catch (My_error& me) {      // wystpi bd My_error
    // mona uywa me.interesting_value i me.what()
}

catch (runtime_error& re) { // wystpi bd runtine_error
    // mona uywa re.what()
}

catch (exception& e) {      // wystpi jaki wyjtek z biblioteki standardowej
    // mona uywa e.what()
}

catch (...) {               // wystpi jaki nie wymieniony wczeniej wyjtek
    // moemy zrobi porzdek w najbliszym otoczeniu
}

---------------
template<typename E>
exception_ptr make_exception_ptr(E e) noexcept;
try {
    throw e;
}
catch(...) {
    return current_exception();
}

---------------
struct My_error : runtime_error {
    My_error(const string&);
    //...
};

void my_code()
{
    try{
        //...
    }
    catch (...) {
        My_error err {"Co si nie udao w funkcji my_code()"};
        //...
        throw_with_nested(err);
    }
}
---------------
void user()
{
    try{
        my_code();
    }
    catch(My_error& err) {

    //... rozwizanie problemw zwizanych z My_error...

        try{
            rethrow_if_nested(err); // ponowne zgoszenie zagniedonego wyjtku, jeli jest
        }
        catch (Some_error& err2) {
            //... rozwizanie problemw zwizanych z Some_error...
        }
    }
}
---------------
template<typename T>
void draw_all(vector<T*>& v)
{
    static_assert(Is_base_of<Shape,T>(),"Niewaciwy typ dla draw_all()");

    for (auto p : v) {
        assert(p!=nullptr);
        //...
    }
}
---------------
ostream& open_file(const string& path)
{
    auto dn = split_into_directory_and_name(path);   // dzieli na {cieka,nazwa}

    error_code err {does_directory_exist(dn.first)}; // pyta "system" o ciek
    if (err) { //err!=0 means error

        //... sprawdzenie, czy da si co zrobi...

        if (cannot_handle_err)
            throw system_error(err);
    }

    //...
    return ofstream{path};
}
---------------
class error_code {
public:
    // reprezentacja: {warto,kategoria} typu {int,const error_category*}
};
---------------
ostream& open_file(const string& path)
{
    auto dn = split_into_directory_and_name(path);         // dzieli na {cieka,nazwa}

    if (error_code err {does_directory_exist(dn.first)}) { // pyta "system" o ciek
        if (err==errc::permission_denied) {
            //...
        }
        else if (err==errc::not_a_directory) {
            //...
        }
        throw system_error(err); // nie da si nic zrobi lokalnie
    }

    //...
    return ofstream{path};
}
---------------
class error_category{
public:
    //... interfejs do konkretnych kategorii pochodnych od error_category...
};
---------------
class system_error : public runtime_error {
public:
    //...
};
---------------
try{
    // co
}
catch (system_error& err) {
    cout << "Przechwycono system_error " << err.what() <<'\n'; // wiadomo o bdzie

    auto ec = err.code();
    cout << "kategoria: " << ec.category().what() <<'\n';
    cout << "warto: " << ec.value() <<'\n';
    cout << "wiadomo: " << ec.message() <<'\n';
}
---------------
class error_condition { // potencjalnie przenone (iso.19.5.3)
public:
    // jak error_code, ale
    // brak operatora wyjciowego (<<) i
    // operacji default_error_condition()
};
---------------
enum class future_errc {
    broken_promise = 1,
    future_already_retrieved,
    promise_already_satisfied,
    no_state
};
---------------
class future_cat : error_category{ // zwracane przez future_category()
public:
    const char* name() const noexcept override { return "future"; }

    string message(int ec) const override;
};

const error_category& future_category() noexcept
{
    static future_cat obj;
    return &obj;
}
---------------
string future_error::message(int ec) const
{
    switch (ec) {
    default:  return "Kod powanego bdu future_error";
    future_errc::broken_promise:  return "future_error: zamana obietnica";
    future_errc::future_already_retrieved:  return "future_error: future zosta lju 
    (pobrany";
    future_errc::promise_already_satisfied: return "future_error: obietnica zostaa ju 
    (speniona";
    future_errc::no_state:  return "future_error: brak stanu";
    }
}
---------------
error_code make_error_code(future_errc e) noexcept
{
    return error_code{int(e),future_category()};
}
---------------
error_code ec1 {7};                            // bd
error_code ec2 {future_errc::no_state};        // OK

ec1 = 9;                                       // bd
ec2 = future_errc::promise_already_satisfied;  // OK
ec2 = errc::broken_pipe;                       // bd: niepoprawna kategoria bdu
---------------
template<>
struct is_error_code_enum<future_errc> : public true_type { };
---------------
template<typename>
struct is_error_code_enum : public false_type { };
error_condition make_error_condition(future_errc e) noexcept;

template<>
struct is_error_condition_enum<future_errc> : public true_type { };
---------------
void problem(errc e)
{
    if (e==EPIPE) {           // bd: brak konwersji errc na int
        //...
    }

    if (e==broken_pipe) {      // bd: broken_pipe poza zakresem
        //...
    }

    if (e==errc::broken_pipe) { // OK
        //...
    }
}