---------------
mutex m; // chroni dostp do wsplnych danych
//...
void f()
{
    unique_lock<mutex> lck {m}; // zajcie muteksu m
    //... praca ze wsplnymi danymi...
}
---------------
void f(int i, int j) // porwnanie X* i unique_ptr<X>
{
    X*p = new X;              // alokacja obiektu typu X
    unique_ptr<X> sp {new X}; // alokacja obiektu typu X i przekazanie jego wskanika do unique_ptr
    //...
    if (i<99) throw Z{};      // moe spowodowa wyjtek
    if (j<77) return;         // moe zwrci przedwczenie
    p->do_something();        // moe spowodowa wyjtek
    sp->do_something();       // moe spowodowa wyjtek
    //...
    delete p;                 // usunicie *p
}
---------------
void f(int i, int j) // uycie zmiennej lokalnej
{
    Xx;
    //...
}
---------------
unique_ptr<X> make_X(int i)
    // tworzy obiekt typu X i od razu przekazuje go do unique_ptr
{
    //... sprawdzenie i itp....
    return unique_ptr<X>{new X{i}};
}
---------------
void f(shared_ptr<fstream>);
void g(shared_ptr<fstream>);

void user(const string& name, ios_base::openmode mode)
{
    shared_ptr<fstream> fp {new fstream(name ,mode)};
    if (!*fp) throw No_file{}; // upewnienie si, czy plik zosta poprawnie otwarty

    f(fp);
    g(fp);
    //...
}
---------------
void f();              // funkcja

struct F {             // obiekt funkcyjny
    void operator()(); // operator wywoywania obiektu F (3.4.3)
};

void user()
{
    thread t1 {f};    // f() dziaa w osobnym wtku
    thread t2 {F()};  // F()() dziaa w osobnym wtku

    t1.join();        // czeka na t1
    t2.join();        // czeka na t2
}
---------------
void f() { cout << "Witaj, "; }

struct F {
    void operator()() { cout << "wiecie rwnolegy!\n"; }
};
---------------
wieWitacie, rwnolejgy!
---------------
void f(vector<double>& v);  // funkcja robica co z v

struct F {                  // obiekt funkcyjny robicy co z v
    vector<double>& v;
    F(vector<double>& vv) :v{vv} { }
    void operator()();      // operator wywoania - 3.4.3
};

int main()
{
    vector<double> some_vec {1,2,3,4,5,6,7,8,9};
    vector<double> vec2 {10,11,12,13,14};

    thread t1 {f,some_vec}; // f(some_vec) dziaa w osobnym wtku
    thread t2 {F{vec2}};    // F(vec2)() dziaa w osobnym wtku

    t1.join();
    t2.join();
}
---------------
void f(const vector<double>& v, double*res); // pobiera dane z v; wynik zapisuje w *res

class F {
public:
    F(const vector<double>& vv, double*p) :v{vv}, res{p} { }
    void operator()();       // zapisuje wynik w *res

private:
    const vector<double>& v; // rdo danych wejciowych
    double*res;              // miejsce zapisu wyniku
};

int main()
{
    vector<double> some_vec;
    vector<double> vec2;
    //...

    double res1;
    double res2;

    thread t1 {f,some_vec,&res1}; // f(some_vec,&res1) dziaa w osobnym wtku
    thread t2 {F{vec2,&res2}};    // F{vec2,&res2}() dziaa w osobnym wtku

    t1.join();
    t2.join();

    cout << res1 << ' ' << res2 << '\n';
}
---------------
mutex m; // muteks do kontroli
int sh;  // wsplne dane

void f()
{
    unique_lock<mutex> lck {m}; // zajcie muteksu
    sh += 7;                    // dziaania niewsplnych danych
} // niejawne zwolnienie muteksu
---------------
class Record {
public:
    mutex rm;
    //...
};
---------------
void f()
{
    //...
    unique_lock<mutex> lck1 {m1,defer_lock}; // defer_lock: nie prbuj jeszcze zaj muteksu
    unique_lock<mutex> lck2 {m2,defer_lock};
    unique_lock<mutex> lck3 {m3,defer_lock};
    //...
    lock(lck1,lck2,lck3);                    // zajmij wszystkie trzy blokady
    //... operacje na wsplnych danych...
} // niejawne zwolnienie wszystkich muteksw
---------------
using namespace std::chrono; // zobacz podrozdzia 35.2

auto t0 = high_resolution_clock::now();
this_thread::sleep_for(milliseconds{20});
auto t1 = high_resolution_clock::now();
cout << "Mino " << duration_cast<nanoseconds>(t1-t0).count() << " nanosekund\n";
---------------
class Message { // obiekt do komunikowania
//...
};

queue<Message> mqueue;    // kolejka wiadomoci
condition_variable mcond; // zmienna komunikujca zdarzenia
mutex mmutex;             // mechanizm blokowania
---------------
void consumer()
{
    while(true) {
        unique_lock<mutex> lck{mmutex};        // zajcie muteksu
        while (mcond.wait(lck)) /* nic nie robi */; // zwalnia lck i czeka
                                              // ponownie zajmuje lck po przebudzeniu
        auto m = mqueue.front();              // odbiera wiadomo
        mqueue .pop();
        lck.unlock();                         // zwalnia lck
        //... przetwarza m...
    }
}
---------------
void producer()
{
    while(true) {
        Message m;
        //... wypenienie wiadomoci...
        unique_lock<mutex> lck {mmutex}; // ochrona operacji
        mqueue .push(m);
        mcond.notify_one();              // powiadomienie
    }                                    // zwolnienie blokady (na kocu zakresu)
}
---------------
X v = fx.get(); // w razie potrzeby poczeka, a warto zostanie obliczona
---------------
void f(promise<X>& px) // zadanie: zapisuje wynik w px
{
    //...
    try{
        X res;
        //... obliczanie wartoci res...
        px.set_value(res);
    }
    catch (...) { // ups: nie mona obliczy res
        // przekazanie wyjtku do wtku przyszoci:
        px.set_exception(current_exception());
    }
}
---------------
void g(future<X>& fx) // zadanie: pobiera wynik z fx
{
    //...
    try{
        X v = fx.g et(); // w razie potrzeby czeka na obliczenie wartoci
        //... operacje przy uyciu v...
    }
    catch (...) { // ups: komu nie udao si obliczy v
        //... obsuga bdu...
    }
}
---------------
double accum(double*beg, double*end, double init)
    // oblicza sum zbioru <beg,end), zaczynajc od wartoci init
{
    return accumulate(beg,end,init);
}
double comp2(vector<double>& v)
{
    using Task_type = double(double*,double*,double);          // typ zadania

    packaged_task<Task_type> pt0 {accum};                      // pakowanie zadania (tzn. accum)
    packaged_task<Task_type> pt1 {accum};

    future<double> f0 {pt0.get_future()};                      // pobranie future pt0
    future<double> f1 {pt1.get_future()};                      // pobranie future pt1

    double*first = &v[0];
    thread t1 {move(pt0),first,first+v.siz e()/2,0};           // uruchomienie wtku dla pt0
    thread t2 {move(pt1),first+v.siz e()/2,first+v.siz e(),0}; // uruchomienie wtku dla pt1

    //...

    return f0.get()+f1.g et(); // pobranie wynikw
}
---------------
double comp4(vector<double>& v)
    // uruchamia wiele zada, jeeli v jest wystarczajco duy
{
    if (v.size()<10000) return accum(v.begin(),v.end(),0.0);

    auto v0 = &v[0];
    auto sz = v.size();
    auto f0 = async(accum,v0,v0+sz/4,0.0);         // pierwsza wiartka
    auto f1 = async(accum,v0+sz/4,v0+sz/2,0.0);    // druga wiartka
    auto f2 = async(accum,v0+sz/2,v0+sz*3/4,0.0);  // trzecia wiartka
    auto f3 = async(accum,v0+sz*3/4,v0+sz,0.0);    // czwarta wiartka

    return f0.get()+f1.g et()+f2.g et()+f3.g et(); // zebranie i poczenie wynikw
}
---------------
using namespace std::chrono; // patrz 35.2

auto t0 = high_resolution_clock::now();
do_work();
auto t1 = high_resolution_clock::now();
cout << duration_cast<milliseconds>(t1-t0).count() << " ms\n";
---------------
constexpr float min = numeric_limits<float>::min(); // najmniejsza dodatnia liczba zmiennoprzecinkowa (40.2)
---------------
constexpr int szi = sizeof(int); // liczba bajtw w typie int
---------------
void test(vector<string>& v, forward_list<int>& lst)
{
    sort(v);   // sortuje wektor
    sort(lst); // sortuje list jednostronnie powizan
}
---------------
template<typename Ran>                                         // dla iteratorw o dostpie swobodnym
void sort_helper(Ran beg, Ran end, random_access_iterator_tag) // Mona indeksowa <beg,end)
{
    sort(beg,end); // sortuje
}
---------------
template<typename For>                                   // dla iteratorw jednokierunkowych
void sort_helper(For beg, For end, forward_iterator_tag) // mona przeglda <beg,end)
{
    vector<Value_type<For>> v {beg,end}; // inicjacja wektora sekwencj <beg,end)
    sor t(v.begin(),v.end());
    copy(v.begin(),v.end(),beg);         // skopiowanie elementw z powrotem
}
---------------
template<typname C>
void sort(C& c)
{
    using Iter = Iterator_type<C>;
    sort_helper(c.begin(),c.end(),Iterator_category<Iter>{});
}
---------------
template<typename C>
    using Iterator_type = typename C::iterator; // typ iteratora dla C

template<typename Iter>
    using Iterator_category = typename std::iterator_traits<Iter>::iterator_category; 
    (// kategoria Iter
---------------
bool b1 = is_arithmetic<int>();    // tak, int jest typem arytmetycznym
bool b2 = is_arithmetic<string>(); // nie, std::string nie jest typem arytmetycznym
---------------
template<typename Scalar>
class complex {
    Scalar re, im;
public:
    static_assert(is_arithmetic<Scalar>(), "Przykro mi, ale obsuguj liczby zespolone 
    (dla typw arytmetycznych ");
    //...
};
---------------
template<typename T>
constexpr bool Is_arithmetic()
{
    return std::is_arithmetic<T>::value ;
}
---------------
template<typename Forward_iterator, typename T, typename Compare>
    pair<Forward_iterator,Forward_iterator>
    equal_range(Forward_iterator first, Forward_iterator last, const T& val, Compare cmp);
---------------
auto rec_eq = [](const Record& r1, const Record& r2) { return r1.name<r2.name;}; 
(// porwnuje nazwiska
void f(const vector<Record>& v) // zaoenie, e v jest posortowany wg pola name
{
    auto er = equal_range(v.begin(),v.end(),Record{"Reg"},rec_eq);
    for (auto p = er.first; p!=er.second; ++p) // drukuje wszystkie jednakowe rekordy
    cout <<*p;                                 // zaoenie, e operator << jest zdefiniowany dla  
                                                                                               // typu Record
}
---------------
void f(vector<string>& v)
{
    auto pp = make_pair(v.begin(),2); // pp jest pair<vector<string>::iterator,int>
    //...
}
---------------
tuple<string,int,double> t2("Sild",123, 3.14); // typ jest jawnie okrelony

auto t = make_tuple(string("led"),10, 1.23); // typ jest dedukowany
                                               // t jest tuple<string,int,double>

string s = get<0>(t); // pobranie pierwszego elementu krotki
int x = get<1>(t);
double d = get<2>(t);
---------------
regex pat (R"(\w{2}\s*\d{5}(-\d{4})?)"); // wzorzec amerykaskiego kodu pocztowego: XXddddd-dddd
                                                                                   //  i niezmienniki
cout << "wzorzec: " << pat << '\n';
---------------
int lineno = 0;
for (string line; getline(cin,line);) { // wczytuje do bufora linijek tekstu
    ++lineno;
    smatch matches;                     // tu trafiaj dopasowane acuchy
    if (regex_search(line,matches,pat)) // szuka pat w line
        cout << lineno << ": " << matches[0] << '\n';
}
---------------
void f()
{
    list<double> lst {1, 2, 3, 4, 5, 9999.99999};
    auto s = accumulate(lst.begin(),lst.end(),0.0); // oblicza sum
    cout << s << '\n';                              // drukuje 10014.9999
}
---------------
template<typename Scalar>
class complex {
public:
    complex(const Scalar& re ={}, const Scalar& im ={});
    //...
};
---------------
void f(complex<float> fl, complex<double> db)
{
    complex<long double> ld {fl+sqrt(db)};
    db += fl*3;
    fl = pow(1/fl,2);
    //...
}
---------------
using my_engine = default_random_engine;            // typ silnika
using my_distribution = uniform_int_distribution<>; // typ rozkadu

my_engine re {};                                    // domylny silnik
my_distribution one_to_six {1,6};                   // rozkad odwzorowujcy na liczby cakowite 1..6
auto die = bind(one_to_six,re);                     // utworzenie generatora

int x = die();                                      // rzut kostk: x otrzymuje warto z przedziau <1,6>
---------------
auto die = bind(uniform_int_distribution<>{1,6}, default_random_engine{});
---------------
Rand_int rnd {1,10}; // tworzy generator liczb losowych dla zbioru <1,10>
int x = rnd();       // x jest liczb z przedziau <1,10>
---------------
class Rand_int {
public:
    Rand_int(int low, int high) :dist{low,high} { }
    int operator()() { return dist(re); } // losuje liczb cakowit
private:
    default_random_engine re;
    uniform_int_distribution<> dist;
};
---------------
int main()
{
    Rand_int rnd {0,4};                  // tworzy rwnomierny generator liczb losowych

    vector<int> histogram(5);            // tworzy wektor o rozmiarze 5
    for (int i=0; i!=200; ++i)
        ++histogram[rnd()];              // wypenia histogram czstociami liczb z przedziau <0:4>

    for (int i = 0; i!=mn.size(); ++i) { // rysuje wykres
        cout << i << '\t';
        for (int j=0; j!=mn[i]; ++j) cout << '*';
        cout << endl;
    }
}
---------------
0 *********************************************
1 *******************************************
2 *******************************
3 ******************************************
4 *****************************************
---------------
template<typename T>
class valarray {
    //...
};
---------------
void f(valarray<double>& a1, valarray<double>& a2)
{
    valarray<double> a = a1*3.14+a2/a1; // Numeryczne operatory tablicowe *, +, / oraz =
    a2 += a1*3.14;
    a = abs(a);
    double d = a2[7];
    //...
}
---------------
static_assert(numeric_limits<char>::is_signed,"Znaki bez znaku!");
static_assert(100000<numeric_limits<int>::max(),"Mae int!");