---------------
while (p && !whitespace(*p)) ++p;
---------------
enum ios_base::iostate {
    goodbit=0, eofbit=1, failbit=2, badbit=4
};
---------------
state = goodbit;
// ...
if (state&(badbit|failbit)) // co nie tak ze strumieniem
---------------
state |= eofbit;
---------------
int old = cin.rdstate(); // rdstate() zwraca stan
// ... dziaania przy uyciu cin...
if (cin.rdstate()^old) { // czy co si zmienio?
    // ...
}
---------------
constexpr unsigned short middle(int a)
{
    static_assert(sizeof(int)==4,"Niespodziewany rozmiar typu int");
    static_assert(sizeof(short)==2,"Niespodziewany rozmiar typu short");
    return (a>>8)&0xFFFF;
}

int x = 0xFF00FF00;   // zaoenie, e sizeof(int)==4
shor t y = middle(x); // y = 0x00FF
---------------
if (a <= b)
    max = b;
else
    max = a;
---------------
max = (a<=b) ? b : a;
---------------
void fct(int*p)
{
    int i = (p) ?*p : std::runtime_error{"Nieoczekiwany nullptr"};
    // ...
}
---------------
void cpy(char*p, const char*q)
{
    while (*p++ =*q++) ;
}
---------------
while (*p++ =*q++) ;
---------------
int length = strlen(q);
for (int i = 0; i<=length; i++)
    p[i] = q[i];
---------------
int i;
for (i = 0; q[i]!=0 ; i++)
    p[i] = q[i];
p[i] = 0; // kocowe zero
---------------
while (*q!=0){
    *p=*q;
    p++; // wskazuje nastpny znak
    q++; // wskazuje nastpny znak
}
*p=0;    // kocowe zero
---------------
while (*q!=0){
    *p++ =*q++;
}
*p=0; // kocowe zero
---------------
while ((*p++ = *q++) != 0) { }
---------------
while (*p++ =* q++) ;
---------------
char* strcpy(char*, const char*); // z <string.h>
---------------
struct Enode {
    Token_value oper;
    Enode*left;
    Enode*right;
    //...
};

Enode*expr(bool get)
{
    Enode*left = term(get);

    for (;;) {
        switch (ts.current().kind) {
        case Kind::plus:
        case Kind::minus:
            left = new Enode {ts.current().kind,left,term(true)};
            break;
        default:
            return left; // zwraca wze
        }
    }
}
---------------
int* p = new int = 7; // bd
---------------
auto pc = new complex<double>; // obiekt complex jest zainicjowany wartoci {0,0}
auto pi = new int;             // obiekt int jest niezainicjowany
---------------
auto pc = new complex<double>{}; // obiekt complex jest zainicjowany wartoci {0,0}
auto pi = new int{};             // obiekt int jest zainicjowany wartoci 0
---------------
void generate(Enode*n)
{
    switch (n->oper) {
    case Kind::plus:
        // uycie n
        delete n; // usunicie obiektu Enode z pamici wolnej
    }
}
---------------
int*p1 = new int{99};
int*p2 = p1;             // potencjalne kopoty
delete p1;               // teraz p2 nie wskazuje poprawnego obiektu
p1 = nullptr;            // daje faszywe wraenie bezpieczestwa
char*p3 = new char{'x'}; // p3 moe teraz wskazywa pami wskazywan przez p2
*p2 = 999;               // to moe powodowa problemy
cout <<*p3 << '\n';      // moe nie wydrukowa x
---------------
void sloppy() // bardzo zy kod
{
    int*p = new int[1000]; // zajcie pamici
    //... uycie *p...
    delete[] p;            // zwolnienie pamici

    //... odczekanie chwil...

    delete[] p;            // ale funkcja sloppy() nie jest wacicielem *p
}
---------------
void f(const string& s)
{
    vector<char> v;
    for (auto c : s)
        v.push_back(c);
    // ...
}
---------------
Token_stream ts{new istringstream{some_string}};
---------------
string reverse(const string& s)
{
    string ss;
    for (int i=s.size()-1; 0<=i; --i)
        ss.push_back(s[i]);
    return ss;
}
---------------
void f(int n)
{
    int*p1 = new int[n]; // potencjalne kopoty
    unique_ptr<int[]> p2 {new int[n]};
    //...
    if (n%2) throw runtime_error("dziwne");
    delete[] p1;         // tu moemy nigdy nie dotrze
}
---------------
char*save_string(const char*p)
{
    char*s = new char[strlen(p)+1];
    strcpy(s,p); // kopiuje z p do s
    return s;
}

int main(int argc, char*argv[])
{
    if (argc < 2) exit(1);
    char*p = save_string(argv[1]);
    //...
    delete[] p;
}
---------------
string save_string(const char*p)
{
    return string{p};
}
int main(int argc, char*argv[])
{
    if (argc < 2) exit(1);
    string s = save_string(argv[1]);
    //...
}
---------------
void f(int n)
{
    vector<int>*p = new vector<int>(n); // pojedynczy obiekt
    int*q = new int[n];                 // tablica
    // ...
    delete p;
    delete[] q;
}
---------------
void f1()
{
    X*p =new X;
    //... uycie *p...
    delete p;
}
---------------
void f2()
{
    X x;
    //... uycie x...
}
---------------
void*operator new(siz e_t);     // alokuje miejsce dla pojedynczego obiektu
void operator delete(void*p);   // jeli (p), dezalokuje przestrze alokowan przy uyciu operator new()
void*operator new[](siz e_t);   // alokuje miejsce dla tablicy
void operator delete[](void*p); // jeli (p), dezalokuje przestrze alokowan przy uyciu operator new[]()
---------------
void f()
{
    vector<char*>v;
    try{
        for (;;) {
            char * p = new char[10000]; // zajmuje troch pamici
            v.push_back(p);             // utworzenie referencji do alokowanej pamici
            p[0] = 'x';                 // uycie alokowanej pamici
        }
    }
    catch(bad_alloc) {
        cerr << "Pami zostaa wyczerpana!\n";
    }
}
---------------
class X {
public:
    X(int);
    //...
};
---------------
void* operator new(size_t, void* p) { return p; } // operator jawnej lokalizacji obiektu

void* buf = reinterpret_cast<void*>(0xF00F);      // znaczcy adres
X* p2 = new(buf) X;                               // tworzy obiekt X w buf;
                                                  // wywouje operator new(sizeof(X),buf)
---------------
void*operator new (size_t sz, void* p) noexcept;  // lokuje obiekt o rozmiarze sz w p
void*operator new[](size_t sz, void* p) noexcept; // lokuje obiekt o rozmiarze sz w p

void operator delete (void* p, void*) noexcept;   // jeli (p), *p jest niepoprawny
void operator delete[](void* p, void*) noexcept;  // jeli (p), *p jest niepoprawny
---------------
class Arena {
public:
    virtual void* alloc(size_t) =0;
    virtual void free(void*) =0;
    //...
};
void* operator new(size_t sz, Arena* a)
{
    return a->alloc(sz);
}
---------------
extern Arena* Persistent;
extern Arena* Shared;

void g(int i)
{
    X* p = new(Persistent) X(i); // X w pamici trwaej
    X* q = new(Shared) X(i);     // X w pamici wsplnej
    //...
}
---------------
void destroy(X* p, Arena* a)
{
    p->~X();    // wywoanie destruktora
    a->free(p); // pami wolna
}
---------------
void f(int n)
{
    int*p = new(nothrow) int[n]; // alokacja n liczb typu int w pamici wolnej
    if (p==nullptr) {            // brak dostpnej pamici
        // ... obsuga bdu alokacji...
    }
    //...
    operator delete(nothrow,p);  // dezalokacja *p
}
---------------
void* operator new(size_t sz, const nothrow_t&) noexcept;   // alokuje sz bajtw; zwraca nullptr
                                                            // w razie niepowodzenia alokacji
void operator delete(void* p, const nothrow_t&) noexcept;   // dezalokuje przestrze alokowan przez new
void* operator new[](size_t sz, const nothrow_t&) noexcept; // alokuje sz bajtw; zwraca nullptr
                                                            // w razie niepowodzenia alokacji
void operator delete[](void* p, const nothrow_t&) noexcept; // dezalokuje przestrze alokowan przez new
---------------
struct S { int a, b; };
struct SS { double a, b; };

void f(S);      // f() pobiera jako argument S

void g(S);
void g(SS);     // g() jest przeciona

void h()
{
    f({1,2});   // OK: wywoanie f(S{1,2})

    g({1,2});   // bd: niejednoznaczne
    g(S{1,2});  // OK: wywoanie g(S)
    g(SS{1,2}); // OK: wywoanie g(SS)
}
---------------
vector<double> v = {1, 2, 3.14};
---------------
const double temp[] = {double{1}, double{2}, 3.14 } ;
const initializer_list<double> tmp(temp,sizeof(temp)/sizeof(double));
vector<double> v(tmp);
---------------
void f()
{
    initializer_list<int> lst {1,2,3};
    cout << *lst.begin() << '\n';
    *lst.begin() = 2; // bd: lst jest niezmienna
    cout << *lst.begin() << '\n';
}
---------------
T x {v}
---------------
struct S { int a, b; };

void f()
{
    S v {7,8};         // bezporednia inicjacja zmiennej
    v = S{7,8};        // przypisanie przy uyciu listy kwalifikowanej
    S* p = new S{7,8}; // tworzenie obiektu w pamici wolnej przy uyciu listy kwalifikowanej
}
---------------
template<class T>
T square(T x)
{
    return x*x;
}
void f(int i)
{
    double d = square(double{i});
    complex<double> z = square(complex<double>{i});
}
---------------
int f(double d, Matrix& m)
{
    int v {7};         // inicjator (bezporednia inicjacja)
    int v2 = {7};      // inicjator (inicjacja kopiujca)
    int v3 = m[{2,3}]; // zaoenie, e m pobiera jako indeksy pary wartoci
    
    v = {8};           // prawy argument przypisania
    v += {88};         // prawy argument przypisania
    {v} = 9;           // bd: nie moe by po lewej stronie przypisania
    v = 7+{10};        // bd: nie moe by argumentem operatora innego ni przypisania
    f({10.0});         // argument funkcji
    return {11};       // zwrot wartoci
}
---------------
int high_value(initializer_list<int> val)
{
    int high = numeric_traits<int>lowest();
    if (val.siz e()==0) return high;

    for (auto x : val)
        if (x>high) high = x;

    return high;
}

int v1 = high_value({1,2,3,4,5,6,7});
int v2 = high_value({-1,2,v1,4,-9,20,v1});
---------------
auto x0 = {};      // bd (brak typu elementw)
auto x1 = {1};     // initializer_list<int>
auto x2 = {1,2};   // initializer_list<int>
auto x3 = {1,2,3}; // initializer_list<int>
auto x4 = {1,2.0}; // bd: lista niejednolita
---------------
template<typename T>
void f(T);
f({});      // bd: nieznany typ inicjatora
f({1});     // bd: niekwalifikowana lista nie pasuje do T
f({1,2});   // bd: niekwalifikowana lista nie pasuje do T
f({1,2,3}); // bd: niekwalifikowana lista nie pasuje do T
---------------
template<class T>
void f2(const vector<T>&);

f2({1,2,3});           // bd: nie mona wydedukowa T
f2({"Kona","Sidney"}); // bd: nie mona wydedukowa T
---------------
f2(vector<int>{1,2,3}); // OK
f2(vector<string>{"Kona","Sidney"}); // OK
---------------
void print_modulo(const vector<int>& v, ostream& os, int m)
    // wysya v[i] do os, jeli v[i]%m==0
{
    for_each(begin(v),end(v),
        [&os,m](int x) { if (x%m==0) os << x << '\n'; }
    );
}
---------------
class Modulo_print {
    ostream& os; // skadowe do przechowywania listy argumentw lokalnych
    int m;
public:
    Modulo_print(ostream& s, int mm) :os(s), m(mm) {} // lista zmiennych
    void operator()(int x) const
        { if (x%m==0) os << x << '\n'; }
};
---------------
void print_modulo(const vector<int>& v, ostream& os, int m)
    // wysya v[i] do os, jeli v[i]%m==0
{
    for_each(begin(v),end(v),Modulo_print{os,m});
}
---------------
void print_modulo(const vector<int>& v, ostream& os, int m)
    // wysya v[i] do os, jeli v[i]%m==0
{
    class Modulo_print {
        ostream& os; // skadowe do przechowywania listy zmiennych lokalnych
        int m;
    public:
        Modulo_print (ostream& s, int mm) :os(s), m(mm) {} // przechwyt
        void operator()(int x) const
            { if (x%m==0) os << x << '\n'; }
    };
    for_each(begin(v),end(v),Modulo_print{os,m});
}
---------------
void print_modulo(const vector<int>& v, ostream& os, int m)
    // wysya v[i] do os, jeli v[i]%m==0
{
    auto Modulo_print = [&os,m] (int x) { if (x%m==0) os << x << '\n'; };
    for_each(begin(v),end(v),Modulo_print);
}
---------------
void print_modulo(const vector<int>& v, ostream& os, int m)
    // wysya v[i] do os, jeli v[i]%m==0
{
    for (auto x : v)
        if (x%m==0) os << x << '\n';
}
---------------
template<class C>
void print_modulo(const C& v, ostream& os, int m)
    // wysya v[i] do os, jeli v[i]%m==0
{
    for (auto x : v)
        if (x%m==0) os << x << '\n';
}
---------------
template<class C>
void print_modulo(const C& v, ostream& os, int m)
    // wysya v[i] do os, jeli v[i]%m==0
{
    breadth_first(begin(v),end(v),
        [&os,m](int x) { if (x%m==0) os << x << '\n'; }
    );
}
---------------
void algo(vector<int>& v)
{
    sort(v.begin(),v.end()); // sortowanie wartoci
    //...
    sort(v.begin(),v.end(),[](int x, int y) { return abs(x)<abs(y); }); // sortowanie wartoci 
                                                                      // bezwzgldnych
    //...
}
---------------
void f(vector<int>& v)
{
    bool sensitive = true;
    //...
    sort(v.begin(),v.end(),
         [](int x, int y) { return sensitive ? x<y : abs(x)<abs(y); } // bd: nie ma dostpu 
                                                                      // do sensitive
    );
}
---------------
void f(vector<int>& v)
{
    bool sensitive = true;
    //...
    sort(v.begin(),v.end()
         [sensitive](int x, int y) { return sensitive ? x<y : abs(x)<abs(y); }
    );
}
---------------
template<typename ... Var>
void algo(int s, Var... v)
{
    auto helper = [&s,&v...] { return s*(h1(v...)+h2(v...)); }
    //...
}
---------------
void setup(Menu& m)
{
    //...
    Point p1, p2, p3;
    // oblicza pozycje dla p1, p2 oraz p3
    m.add("Narysuj trjkt",[&]{ m.draw(p1,p2,p3); }); // potencjalna katastrofa
    //...
}
---------------
m.add("Narysuj trjkt",[=]{ m.draw(p1,p2,p3); });
---------------
template<typename U, typename V>
ostream& operator<<(ostream& os, const pair<U,V>& p)
{
    return os << '{' << p.first << ',' << p.second << '}';
}
void print_all(const map<string,int>& m, const string& label)
{
    cout << label << ":\n{\n";
    for_each(m.begin(),m.end(),
         [](const pair<string,int>& p) { cout << p << '\n'; }
    );
    cout << "}\n";
}
---------------
class Request {
    function<map<string,string>(const map<string,string>&)> oper; // operacja
    map<string,string> values;              // argumenty
    map<string,string> results;             // cele
public:
    Request(const string& s);               // parsuje i zapisuje danie

    void execute()
    {
         [this]() { results=oper(values); } // wywoanie oper na values w celu otrzymania wynikw
    }
};
---------------
void algo(vector<int>& v)
{
    int count = v.size();
    std::g enerate(v.begin(),v.end(),
         [count]()mutable{ return --count; }
    );
}
---------------
void g(double y)
{
    [&]{ f(y); }                                               // typ zwrotny to void
    auto z1 = [=](int x){ return x+y; }                        // typ zwrotny to double
    auto z2 = [=,y]{ if (y) return 1; else return 2; }         // bd: zbyt skomplikowana tre,
                                                               // aby wydedukowa typ zwrotny
    auto z3 =[y]() { return 1 : 2; }                           // typ zwrotny to int
    auto z4 = [=,y]()->int { if (y) return 1; else return 2; } // OK: wprost okrelony typ zwrotny
}
---------------
auto rev = [&rev](char*b, char*e)
    { if (1<e-b) { swap(*b,*--e); rev(++b,e); } }; // bd
---------------
void f(string& s1, string& s2)
{
    function<void(char* b, char* e)> rev =
         [&](char* b, char* e) { if (1<e-b) { swap(*b,*--e); rev(++b,e); } };
    rev(&s1[0],&s1[0]+s1.size());
    rev(&s2[0],&s2[0]+s2.size());
}
---------------
void g(vector<string>& vs1, vector<string>& vs2)
{
    auto rev = [&](char* b, char* e) { while (1<e-b) swap(*b++,*--e); };

    rev(&s1[0],&s1[0]+s1.size());
    rev(&s2[0],&s2[0]+s2.size());
}
---------------
double (*p1)(double) = [](double a) { return sqrt(a); };
double (*p2)(double) = [&](double a) { return sqrt(a); }; // bd: lambda przechwytuje zmienne
double (*p3)(int) = [](int a) { return sqrt(a); };        // bd: typy argumentw nie zgadzaj si
---------------
double d = 1234567890; // typ cakowity na zmiennoprzecinkowy
int i = d;             // typ zmiennoprzecinkowy na cakowity
---------------
template<class Target, class Source>
Target narrow_cast(Source v)
{
    auto r = static_cast<Target>(v); // konwertuje warto na typ docelowy
    if (static_cast<Source>(r)!=v)
        throw runtime_error("Operacja narrow_cast<>() nie powioda si");
    return r;
}
---------------
void test(double d, int i, char*p)
{
    auto c1 = narrow_cast<char>(64);
    auto c2 = narrow_cast<char>(-64);      // zgosi wyjtek, jeli char bd bez znaku
    auto c3 = narrow_cast<char>(264);      // zgosi wyjtek, jeli char bd 8-bitowe i ze znakiem

    auto d1 = narrow_cast<double>(1/3.0F); // OK
    auto f1 = narrow_cast<float>(1/3.0);   // pewnie zgosi wyjtek

    auto c4 = narrow_cast<char>(i);        // moe spowodowa wyjtek
    auto f2 = narrow_cast<float>(d);       // moe spowodowa wyjtek

    auto p1 = narrow_cast<char*>(i);       // bd czasu kompilacji
    auto i1 = narrow_cast<int>(p);         // bd czasu kompilacji

    auto d2 = narrow_cast<double>(i);      // moe spowodowa wyjtek (ale raczej si to nie stanie)
    auto i2 = narrow_cast<int>(d);         // moe spowodowa wyjtek
}
---------------
auto d1 = double{2};     // d1==2.0
double d2 {double{2}/4}; // d1==0.5
---------------
void f(int);
void f(double);

void g(int i, double d)
{
    f(i);                       // wywoanie f(int)
    f(double{i});               // bd: notacja {} nie umoliwia zamiany int na typ zmiennoprzecinkowy

    f(d);                       // wywoanie f(double)
    f(int{d});                  // bd: {} nie skraca wartoci
    f(static_cast<int>(d));     // wywoanie f(int) ze skrcon wartoci

    f(round(d));                    // wywoanie f(double) z zaokrglon wartoci
    f(static_cast<int>(lround(d))); // wywoanie f(int) z zaokrglon wartoci,
                                    // jeli d jest za dua dla typu int, to i tak nastpi skrcenie
}
---------------
static_assert(sizeof(int)==sizeof(double),"Niespodziewane rozmiary");

int x = numeric_limits<int>::max(); // najwiksza moliwa warto cakowitoliczbowa
double d = x;
int y = x;
---------------
double d { 1234 }; // w porzdku
---------------
void g2(char* p)
{
    int x = int{p};    // bd: nie mona konwertowa char* na int
    using Pint = int*;
    int* p2 = Pint{p}; // bd: nie mona konwertowa char* na int*
    //...
}
---------------
template<class T> void f(const T&);

void g3()
{
    f(int{});             // domylna warto typu int
    f(complex<double>{}); // domylna warto typu complex
    // ...
}
---------------
IO_device* d1 = reinterpret_cast<IO_device*>(0Xff00); // urzdzenie pod adresem 0Xff00
---------------
void*  my_allocator(size_t);

void f()
{
    int* p = static_cast<int*>(my_allocator(100)); // nowo alokowane obiekty uywane jako int
    //...
}
---------------
char x = 'a';
int* p1 = &x;                         // bd: nie ma niejawnej konwersji char* na int*
int* p2 = static_cast<int*>(&x);      // bd: nie ma niejawnej konwersji char* na int*
int* p3 = reinterpret_cast<int*>(&x); // OK, ale robisz to na wasn odpowiedzialno

struct B { /*...*/ };
struct D : B { /*...*/ };                // patrz 3.2.2 i 20.5.2

B*pb = new D;                         // OK: niejawna konwersja D* na B*
D*pd = pb;                            // bd: nie ma niejawnej konwersji B* na D*
D*pd = static_cast<D*>(pb);           // OK
---------------
void f(double d)
{
    int i = int(d);         // skrcenie d
    complex z = complex(d); // utworzenie typu complex z d
    //...
}
---------------
void f(double d, char* p)
{
    int a = int(d); // skrcenie
    int b = int(p); // nieprzenone
    //...
}