---------------
a = b+c;  // instrukcja wyraeniowa
if (a==7) // instrukcja if
    b=9;  // dziaanie zostanie wykonane, jeli a==9
---------------
instrukcja:
    deklaracja
    wyraenieopc
    { lista instrukcjiopc }
    try { lista instrukcjiopc } lista-obsugi

    case wyraenie-stae : instrukcja
    default : instrukcja
    break ;
    continue ;

    return wyraenieopc ;

    goto identyfikator ;
    identyfikator : instrukcja

    instrukcja-wyboru
    instrukcja-iteracyjna

instrukcja-wyboru:
    if (warunek) instrukcja
    if (warunek) instrukcja else instrukcja
    switch (warunek) instrukcja

instrukcja-iteracyjna:
    while (warunek) instrukcja
    do instrukcja while (wyraenie) ;
    for (warunek instrukcji-inic-foropc ; wyraenieopc) instrukcja
    for (deklaracja-inic-for : wyraenie) instrukcja

lista-instrukcji:
    instrukcja lista-instrukcjiopc

warunek:
    wyraenie
    specyfikator typu deklarator = wyraenie
    specyfikator typu deklarator {wyraenie}

lista-obsugi:
    procedura-obsugi lista-obsugiopc

procedura-obsugi:
    catch ([[deklaracja-wyjtku) {lista-instrukcjiopc}
---------------
Instrukcja-inic-forDeklaracja-inic-forbloki-tryvoid f(vector<string>& v, int i, const char*p)
{
    if (p==nullptr) return;
    if (i<0 || v.siz e()<=i)
        error("Niepoprawny indeks");
    string s = v[i];
    if (s == p) {
        // ...
    }
    // ...
}
---------------
void use()
{
    string s1;
    s1 = "Lepsze jest wrogiem dobrego.";
    // ...
}
---------------
string s2 {"Wolter"};
---------------
void input()
{
    int buf[max];
    int count = 0;
    for (int i; cin>>i;) {
        if (i<0) error("Nieoczekiwana warto ujemna");
        if (count==max) error("Przepenienie bufora");
        buf[count++] = i;
    }
    // ...
}
---------------
if (warunek) instrukcja
if (warunek) instrukcja else instrukcja
switch (warunek) instrukcja
---------------
if(x) // ...
---------------
if (x != 0) //...
---------------
if (p) // ...
---------------
if (p != nullptr) // ...
---------------
enum E1 { a, b };
enum class E2 { a, b };

void f(E1 x, E2 y)
{
    if (x)        // OK
        // ...
    if (y)        // bd: niemoliwa konwersja na bool
        // ...
    if (y==E2::a) // OK
        // ...
}
---------------
&&    ||    !
---------------
if (p && 1<p->count) // ...
---------------
int max(int a, int b)
{
    return (a>b)?a:b; // zwraca wiksz spord wartoci a i b
}
---------------
void f2(int i)
{
    if (i) {
        int x = i+2;
        ++x;
        // ...
    }
    else {
        ++x; // bd: x nie naley do zakresu
    }
    ++x;     // bd: x nie naley do zakresu
}
---------------
void f1(int i)
{
    if (i)
        int x = i+2; // bd: deklaracja gazi instrukcji if
}
---------------
void f(int i)
{
    switch (i) {
    case 2.7: // bd: uycie liczby zmiennoprzecinkowej w case
        // ...
    case 2:
        // ...
    case 4-2: // bd: liczba 2 uyta dwa razy w etykietach case
        // ...
};
---------------
switch (val) {
case 1:
    f();
    break;
case 2:
    g();
    break;
default:
    h();
    break;
}
---------------
if (val == 1)
    f();
else if (val == 2)
    g();
else
    h();
---------------
switch (val) { // uwaga
case 1:
    cout << "case 1\n";
case 2:
    cout << "case 2\n";
default:
    cout << "default: nie znaleziono odpowiedniego przypadku\n";
}
---------------
case 1
case 2
default: nie znaleziono odpowiedniego przypadku
---------------
switch (action) { // obsuga pary (akcja, warto)
case do_and_print:
    act(value);
    // brak instrukcji: nastpi przejcie do print
case print:
    print(value);
    break;
// ...
}
---------------
enum class Vessel { cup, glass, goblet, chalice };

void problematic(Vessel v)
{
    switch (v) {
    case Vessel::cup:     /*...*/  break;
    case Vessel::glass:   /*...*/  break;
    case Vessel::goblet:  /*...*/  break;
    }
}
---------------
void f(int i)
{
    switch (i) {
    case 0:
        int x;     // niezainicjowana
        int y = 3; // bd: deklaracj mona obej (jawnie zainicjowana)
        string s;  // bd: deklaracj mona obej (niejawnie zainicjowana)
    case 1:
        ++x;       // bd: uycie niezainicjowanego obiektu
        ++y;
        s = "Paskudne!";
    }
}
---------------
if (double d = prim(true)) {
    left /= d;
    break;
}
---------------
double d;
//...
d2 = d;  // ups!
//...
if (d = prim(true)) {
    left /= d;
    break;
}
//...
d = 2.0; // dwa niepowizane ze sob uycia zmiennej d
---------------
while (warunek) instrukcja
do instrukcja while (wyraenie);
for (warunek instrukcji-inic-foropc; wyraenieopc) instrukcja
for (deklaracja-for : wyraenie) instrukcja
---------------
int sum(vector<int>& v)
{
    int s = 0;
    for (int x : v)
        s+=x;
    return s;
}
---------------
int sum2(vector<int>& v)
{
    int s = 0;
    for (auto p = begin(v); p!=end(v); ++p)
        s+=*p;
    return s;
}
---------------
void incr(vector<int>& v)
{
    for (int& x : v)
        ++x;
}
---------------
template<class T> T accum(vector<T>& v)
{
    T sum = 0;
    for (const T& x : v)
        sum += x;
    return sum;
}
---------------
void f(int v[], int max)
{
    for (int i = 0; i!=max; ++i)
        v[i] = i*i;
}
---------------
void f(int v[], int max)
{
    int i = 0;        // zmienna ptlowa
    while (i!=max) {  // sprawdzenie warunku zakoczenia
        v[i] = i*i;   // wykonanie treci ptli
        ++i;          // zwikszenie wartoci zmiennej ptlowej
    }
}
---------------
for (auto p = begin(c); c!=end(c); ++p) {
    // ... uycie iteratora p dla elementw w kontenerze c...
}
---------------
for (string s; cin>>s;)
    v.push_back(s);
---------------
for (;;) { // wieczno
    //...
}
---------------
while(true) { // wieczno
    //...
}
---------------
template<class Iter, class Value>
Iter find(Iter first, Iter last, Value val)
{
    while (first!=last &&*first!=val)
        ++first;
    return first;
}
---------------
void print_backwards(char a[], int i) // i musi by wartoci dodatni
{
    cout << '{';
    do {
        cout << a[--i];
    } while (i);
    cout << '}';
}
---------------
void f(vector<string>& v, string terminator)
{
    char c;
    string s;
    while (cin>>c) {
        // ...
        if (c == '\n') break;
        // ...
    }
}
---------------
void find_prime(vector<string>& v)
{
    for (int i = 0; i!=v.size(); ++i) {
        if (!prime(v[i]) continue;
        return v[i];
    }
}
---------------
void find_prime(vector<string>& v)
{
    for (int i = 0; i!=v.size(); ++i) {
        if (prime(v[i]) {
            return v[i];
        }
    }
}
---------------
goto identyfikator ;
identyfikator : instrukcja
---------------
void do_something(int i, int j)
    // robi co z dwuwymiarow macierz o nazwie mn
{
    for (i = 0; i!=n; ++i)
        for (j = 0; j!=m; ++j)
            if (nm[i][j] == a)
                goto found;
    // nie znaleziono
    // ...
found:
    // nm[i][j] == a
}
---------------
// zmienna v musi zosta zainicjowana
// zmienna v moe by uywana tylko przez funkcj f()
// funkcj init() naley wywoa przed wszystkimi innymi funkcjami w tym pliku
// funkcj cleanup() naley wywoa na zakoczenie dziaania programu
// nie uywaj funkcji weird()
// funkcja f(int...) przyjmuje dwa lub trzy argumenty
---------------
a = b+c; // a ma warto b+c
count++; // zwikszenie licznika
---------------
// tbl.c: implementacja tablicy symboli
/*
  Eliminacja Gaussa z czciowym wyborem elementu gwnego.
  Patrz Kowalski: "Podstawy..." str. 411
*/
// scan(p,n,c) wymaga, aby argument p wskazywa tablic przynajmniej n-elementow
// sort(p,q) sortuje elementy przedziau <p,q) przy uyciu operatora porwnywania <
// poprawione w celu dodania obsugi niepoprawnych dat. Bjarne Stroustrup, 29 lutego 2013
---------------
/*
usunicie kosztownego sprawdzania
if (check(p,q)) error("bad p q") /* tego nie powinno by */
*/