---------------
unsigned char c1 = 64;   // dobrze zdefiniowane: char zajmuje przynajmniej 8 bitw i zawsze mona w nim 
                                                   // zapisa liczb 64
unsigned char c2 = 1256; // zdefiniowane przez implementacj: jeli char ma 8 bitw, nastpi obcicie
---------------
static_assert(4<=sizeof(int),"Za may rozmiar sizeof(int)");
---------------
const int size = 4*1024;
char page[siz e];

void f()
{
    page[siz e+siz e]=7; // niezdefiniowane
}
---------------
x=y+f(2);
---------------
float x;      // x jest zmienn zmiennoprzecinkow
int y = 7;    // y jest zmienn cakowitoliczbow o pocztkowej wartoci 7
float f(int); // f jest funkcj pobierajc argument typu int i zwracajc liczb zmiennoprzecinkow
---------------
void f(int a, int b)
{
    bool b1 {a==b};
    //...
}
---------------
bool is_open(File*);

bool greater(int a, int b) { return a>b; }
---------------
bool b1 = 7;   // 7!=0, a wic b otrzymuje warto true
bool b2 {7};   // bd: zwenie (2.2.2, 10.5)

int i1 = true; // i1 otrzymuje warto 1
int i2 {true}; // i2 otrzymuje warto 1
---------------
void f(int i)
{
    bool b {i!=0};
    //...
};
---------------
bool a = true;
bool b = true;

bool x = a+b;  // a+b wynosi 2, wic x otrzymuje warto true
bool y = a||b; // a||b wynosi 1, wic y otrzymuje warto true (|| oznacza "lub")
bool z = a-b;  // a-b wynosi 0, wic z otrzymuje warto false
---------------
void g(int*p)
{
    bool b = p;           // zawa do true lub false
    bool b2 {p!=nullptr}; // bezporedni test nullptr

    if (p) { // rwnowane z p!=nullptr
        //...
    }
}
---------------
char ch = 'a';
---------------
void intval()
{
    for (char c; cin >> c; )
    cout << "Warto znaku '" << c << "' to " << int{c} << '\n';
}
---------------
void digits()
{
    for (int i=0; i!=10; ++i)
    cout << static_cast<char>('0'+i);
}
---------------
char c = 255; // 255 to "same jedynki", a szesnastkowo 0xFF
int i = c;
---------------
void f(char c, signed char sc, unsigned char uc)
{
    char*pc = &uc;          // bd: nie mona przekonwertowa wskanika
    signed char*psc = pc;   // bd: nie mona przekonwertowa wskanika
    unsigned char*puc = pc; // bd: nie mona przekonwertowa wskanika
    psc = puc;              // bd: nie mona przekonwertowa wskanika
}
---------------
void g(char c, signed char sc, unsigned char uc)
{
    c = 255; // zaley od implementacji, czy char jest ze znakiem, czy bez i czy zajmuje 8 bitw
    c = sc;  // OK
    c = uc;  // zaley od implementacji, czy char jest ze znakiem i czy warto uc jest za dua
    sc = uc; // zaley od implementacji, czy warto uc jest za dua
    uc = sc; // OK: konwersja na typ bez znaku
    sc = c;  // zaley od implementacji, czy char jest bez znaku i czy warto c jest za dua
    uc = c;  // OK: konwersja na typ bez znaku
}
---------------
signed char sc = -160;
unsigned char uc = sc; // uc == 116 (bo 256-160==116)
cout << uc;            // drukuje 't'

char count[256];       // zaoenie, e char ma 8 bitw
++count[sc];           // prawdopodobna katastrofa: dostp poza zakresem
++count[uc];           // OK
---------------
char v1[] = "a\xah\129";  // 6 znakw: 'a' '\xa' 'h' '\12' '9' '\0'
char v2[] = "a\xah\127";  // 5 znakw: 'a' '\xa' 'h' '\127' '\0'
char v3[] = "a\xad\127";  // 4 znaki: 'a' '\xad' '\127' '\0'
char v4[] = "a\xad\0127"; // 5 znakw: 'a' '\xad' '\012' '7' '\0'
---------------
U'\UFADEBEEF'
u'\uDEAD'
u'\xDEAD'
---------------
7    1234     976     12345678901234567890
---------------
cout << 0xF0UL << ' ' << 0LU << '\n';
---------------
1.23     .23     0.23     1.     1.0     1.2e10     1.23e-15
---------------
65.43 e - 21
---------------
3.14159265f     2.0f     2.997925F     2.9e-3f
---------------
3.14159265L     2.0L     2.997925L     2.9e-3L
---------------
1LU  // unsigned long
2UL  // unsigned long
3ULL // unsigned long long
4LLU // unsigned long long
5LUL // bd
---------------
1L   // long int
1.0L // long double
---------------
"foo bar"s // litera typu std::string
123_km     // litera typu Distance
---------------
void x;   // bd: nie ma obiektw void
void& r;  // bd: nie ma referencji do void
void f(); // funkcja f nie zwraca wartoci (12.1.4)
void*pv;  // wskanik do obiektu nieznanego typu (7.2.1)
---------------
#include <limits> // 40.2
#include <iostream>
int main()
{
    cout << "rozmiar long " << sizeof(1L) << '\n';
    cout << "rozmiar long long " << sizeof(1LL) << '\n';

    cout << "najwikszy zmiennoprzecinkowy == " << std::numeric_limits<float>::max() << '\n';
    cout << "char jest ze znakiem == " << std::numeric_limits<char>::is_signed << '\n';
}
---------------
int16_t x {0xaabb};                 // 2 bajty
int64_t xxxx {0xaaaabbbbccccdddd};  // 8 bajtw
int_least16_t y;                    // przynajmniej 2 bajty (jak int)
int_least32_t yy                    // przynajmniej 4 bajty (jak long)
int_fast32_t z;                     // najszybszy typ int o rozmiarze przynajmniej 4 bajtw
---------------
void*allocate(size_t n); // pobiera n bajtw
---------------
auto ac = alignof('c'); // wyrwnanie char
auto ai = alignof(1);   // wyrwnanie int
auto ad = alignof(2.0); // wyrwnanie double

int a[20];
auto aa = alignof(a);  // wyrwnanie int
---------------
void user(const vector<X>& vx)
{
    constexpr int bufmax = 1024;
    alignas(X) buffer[bufmax]; // niezainicjowane

    const int max = min(vx.size(),bufmax/sizeof(X));
    uninitialized_copy(vx.begin(),vx.begin()+max,buffer);
    //...
}
---------------
char ch;
string s;
auto count = 1;
const double pi {3.1415926535897};
extern int error_number;

const char*name = "Njal";
const char*season[] = { "wiosna", "lato", "jesie", "zima" };
vector<string> people { name, "Skarphedin", "Gunnar" };

struct Date { int d, m, y; };
int day(Date*p) { return p->d; }
double sqrt(double);
template<class T> T abs(T a) { return a<0 ? -a : a; }

constexpr int fac(int n) { return (n<2)?1:n*fac(n-1); } // moliwa ewaluacja w czasie kompilacji (2.2.3)
constexpr double zz { ii*fac(7) };                      // inicjacja w czasie kompilacji

using Cmplx = std::complex<double>;                     // alias typu (3.4.5, 6.5)
struct User;                                            // nazwa typu
enum class Beer { Carlsberg, Tuborg, Thor };
namespace NS { int a; }
---------------
char ch;                         // rezerwuje pami dla zmiennej typu char i inicjuje j wartoci 0
auto count = 1;                  // rezerwuje pami dla zmiennej typu int zainicjowanej wartoci 1
const char*name = "Njal";        // rezerwuje pami dla wskanika typu char
                                 // rezerwuje pami dla literau acuchowego "Njal"
                                 // inicjuje wskanik adresem tego literau

struct Date { int d, m, y; };    // Date jest struktur zawierajc trzy skadowe
int day(Date*p) { return p->d; } // day jest funkcj wykonujc okrelony kod

using Point = std::complex<short>; // Point jest nazw dla std::complex<short>
---------------
double sqrt(double);     // deklaracja funkcji
extern int error_number; // deklaracja zmiennej
struct User;             // deklaracja nazwy typu
---------------
double sqrt(double d) { /*...*/ }
int error_number = 1;
struct User { /*...*/ };
---------------
int count;
int count; // bd: ponowna definicja

extern int error_number;
extern short error_number; // bd: rne typy
---------------
extern int error_number;
extern int error_number; // OK: ponowna deklaracja
---------------
struct Date { int d, m, y; };
using Point = std::complex<short>; // Point jest nazw dla std::complex<short>
int day(Date*p) { return p->d; }
const double pi {3.1415926535897};
---------------
void f()
{
    int count {1};              // inicjacja count wartoci 1
    const char*name {"Bjarne"}; // name jest zmienn wskazujc sta (7.5)
    count = 2;                  // przypisanie 2 do count
    name = "Marian";
}
---------------
char ch;
string s;
---------------
const char*kings[] = { "Antigonus", "Seleucus", "Ptolemy" };
---------------
const c = 7;     // bd: brak typu

gt(int a, int b) // bd: brak typu zwrotnego
{
    return (a>b) ? a : b;
}

unsigned ui;     // OK: unsigned oznacza unsigned int
long li;         // OK: long oznacza long int
---------------
int x, y; // int x; int y;
---------------
int* p, y;      // int* p; int y; NIE int* y;
int x, *q;      // int x; int* q;
int v[10], *pv; // int v[10]; int* pv;
---------------
hej       to_jest_bardzo_dlugi_identyfikator_i_lepiej_go_nie_stosowac
DEFINED   foO        bAr         u_nazwa    PiataKlepka
var0      var1       CLASS       _class     ___
---------------
012       a fool     $sys     class     3var
pay.due   foo~bar    .name    if
---------------
int x;         // globalna nazwa x

void f()
{
    int x;     // lokalna nazwa x zasania globaln nazw x
    x=1;       // przypisanie przy uyciu lokalnej nazwy x
    {
        int x; // zasania pierwsz lokaln nazw x
        x=2;   // przypisanie przy uyciu drugiej lokalnej nazwy x
    }
    x=3;       // przypisanie przy uyciu pierwszej lokalnej nazwy x
}

int* p = &x;   // pobranie adresu przy uyciu globalnej nazwy x
---------------
int x;

void f2()
{
    int x = 1; // zasonicie globalnej nazwy x
    ::x = 2;   // przypisanie przy uyciu globalnej nazwy x
    x=2;       // przypisanie przy uyciu lokalnej nazwy x
    // ...
}
---------------
int x = 97;

void f3()
{
    int x = x; // zainicjuj x jej wasn (niezainicjowan) wartoci
}
---------------
int x = 11;
void f4()      // uycie dwch rnych obiektw o nazwie x w jednym zakresie
{
    int y = x; // uycie globalnej nazwy x: y = 11
    int x = 22;
    y=x;       // uycie lokalnej nazwy x: y = 22
}
---------------
void f5(int x)
{
    int x; // bd
}
---------------
void f(vector<string>& v, list<int>& lst)
{
    for (const auto& x : v) cout << x << '\n';
    for (auto x : lst) cout << x << '\n';
    for (int i = 0, i!=v.siz e(), ++i) cout << v[i] << '\n';
    for (auto i : {1, 2, 3, 4, 5, 6, 7}) cout << i << '\n';
}
---------------
X a1 {v};
X a2 = {v};
X a3=v;
X a4(v);
---------------
int x1 = 0;
char c1 = 'z';
---------------
void f(double val, int val2)
{
    int x2 = val;   // if val==7.9, x2 ma warto 7
    char c2 = val2; // if val2==1025, c2 ma warto 1
    int x3 {val};   // bd: moliwe skrcenie
    char c3 {val2}; // bd: moliwe zawenie
    char c4 {24};   // OK: liczb 24 mona dokadnie przedstawi w typie char
    char c5 {264};  // bd (przy zaoeniu, e typ char ma 8 bitw): 264 nie mona reprezentowa jako char
    int x4 {2.0};   // bd: nie mona dokona konwersji z double na int
    // ...
}
---------------
auto z1 {99}; // z1 jest initializer_list<int>
auto z2 = 99; // z2 jest int
---------------
vector<int> v1 {99}; // v1 jest wektorem zawierajcym 1 element o wartoci 99
vector<int> v2(99);  // v2 jest wektorem zawierajcym 99 elementw o domylnej wartoci 0 kady
---------------
vector<string> v1{"hello!"}; // v1 jest wektorem zawierajcym 1 element o wartoci hello!
vector<string> v2("hello!"); // bd: aden konstruktor wektora nie przyjmuje literau acuchowego
---------------
int x4 {};        // x4 ma warto 0
double d4 {};     // d4 ma warto 0.0
char* p {};       // p to nullptr
vector<int> v4{}; // v4 jest pustym wektorem
string s4 {};     // s4 ma warto ""
---------------
constexpr int max = 1024*1024;
char buf[max];
some_stream.g et(buf,max); // wczytuje najwyej max znakw do buf
---------------
char buf[max] {};          // inicjacja kadego znaku wartoci 0
---------------
int a;    // oznacza int a{};, a wic a ma warto 0
double d; // oznacza double d{};, a wic d ma warto 0.0
---------------
void f()
{
    int x;                    // x nie ma zdefiniowanej wartoci
    char buf[1024];           // buf[i] nie ma zdefiniowanej wartoci

    int* p {new int};         // *p nie ma zdefiniowanej wartoci
    char* q {new char[1024]}; // q[i] nie ma zdefiniowanej wartoci

    string s;                 // s=="", bo typ string ma konstruktor domylny
    vector<char> v;           // v=={}, bo vector ma konstruktor domylny

    string* ps {new string};  // *ps is "", , bo string ma konstruktor domylny
    //...
}
---------------
void ff()
{
    int x {};                   // x ma warto 0
    char buf[1024]{};           // buf[i] ma warto 0 dla wszystkich i

    int* p {new int{10}};       // *p ma warto 10
    char* q {new char[1024]{}}; // q[i] ma warto 0 dla wszystkich i

    // ...
}
---------------
int a[] = { 1, 2 };                        // inicjator tablicy
struct S { int x, string s };
Ss={1,"Helios" };                          // inicjator struktury
complex<double> z = { 0, pi };             // uycie konstruktora
vector<double> v = { 0.0, 1.1, 2.2, 3.3 }; // uycie konstruktora listy
---------------
complex<double> z(0,pi);  // uycie konstruktora
vector<double> v(10,3.3); // uycie konstruktora: v ma 10 elementw zainicjowanych wartoci 3.3
---------------
complex<double> z1(1,2); // inicjacja w stylu funkcyjnym (przy uyciu konstruktora)
complex<double> f1();    // deklaracja funkcji

complex<double> z2 {1,2}; // inicjacja przy uyciu konstruktora wartoci {1,2}
complex<double> f2 {};    // inicjacja przy uyciu konstruktora wartoci domyln {0,0}
---------------
auto x1 {1,2,3,4};         // x1 jest initializer_list<int>
auto x2 {1.0, 2.25, 3.5 }; // x2 jest initializer_list<double>
auto x3 {1.0,2};           // bd: nie mona wydedukowa typu dla {1.0,2} (6.3.6.2)
---------------
int a1 = 123;
char a2 = 123;
auto a3 = 123; // typ a3 to int
---------------
template<class T> void f1(vector<T>& arg)
{
    for (vector<T>::iterator p = arg.begin(); p!=arg.end(); ++p)
        *p=7;

    for (auto p = arg.begin(); p!=arg.end(); ++p)
        *p=7;
}
---------------
void f(double d)
{
    constexpr auto max = d+7;
    int a[max]; // bd: granica tablicy nie jest wartoci cakowit
    // ...
}
---------------
void f(vector<int>& v)
{
    for (const auto& x : v) { // x jest const int&
        //...
    }
}
---------------
void g(int& v)
{
    auto x = v;  // x jest typu int (nie int&)
    auto& y = v; // y jest typu int&
}
---------------
char v1 = 12345; // 12345 jest typu int
int v2 = 'c';    // 'c' jest typu char
T v3 = f();
---------------
char v1 {12345}; // bd: zawenie
int v2 {'c'};    // w porzdku: niejawna konwersja char->int
T v3 {f()};      // zadziaa tylko, jeli typ f() mona niejawnie przekonwertowa na T
---------------
auto v1 = 12345; // v1 jest typu int
auto v2 = 'c';   // v2 jest typu char
auto v3 = f();   // v3 jest jakiego odpowiedniego typu
---------------
auto v1 {12345}; // v1 jest list typu int
auto v2 {'c'};   // v2 jest list typu char
auto v3 {f()};   // v3 jest list jakiego odpowiedniego typu
---------------
auto x0 {};      // bd: nie mona wydedukowa typu
auto x1 {1};     // lista typu int z jednym elementem
auto x2 {1,2};   // lista typu int z dwoma elementami
auto x3 {1,2,3}; // lista typu int z trzema elementami
---------------
template<class T, class U>
auto operator+(const Matrix<T>& a, const Matrix<U>& b) -> Matrix<decltype(T{}+U{})>;
---------------
template<class T, class U>
auto operator+(const Matrix<T>& a, const Matrix<U>& b) -> Matrix<decltype(T{}+U{})>
{
    Matrix<decltype(T{}+U{})> res;
    for (int i=0; i!=a.rows(); ++i)
        for (int j=0; j!=a.cols(); ++j)
            res(i,j) += a(i,j) + b(i,j);
    return res;
}
---------------
void f(vector<string>& vs)
{
    vector<string>& v2 = std::move(vs); // przenosi vs do v2
    // ...
}
---------------
using Pchar = char*;       // wskanik do znaku
using PF = int(*)(double); // wskanik do funkcji przyjmujcej typ double i zwracajcej int
---------------
template<class T>
class vector {
    using value_type = T; // kady kontener zawiera value_type
    // ...
};

template<class T>
class list {
    using value_type = T; // kady kontener zawiera value_type
    // ...
};
---------------
Pchar p1 = nullptr; // p1 to char*
char* p3 = p1;      // w porzdku
---------------
typedef int int32_t;      // rwnoznaczne z using int32_t = int;
typedef short int16_t;    // rwnoznaczne z using int16_t = short;
typedef void(*PtoF)(int); // rwnoznaczne z using PtoF = void(*)(int);
---------------
using int32_t = long;
---------------
template<typename T>
    using Vector = std::vector<T, My_allocator<T>>;
---------------
using Char = char;
using Uchar = unsigned Char; // bd
using Uchar = unsigned char; // OK