---------------
int main() { } // najmniejszy moliwy program w jzyku C++
---------------
#include <iostream>

int main()
{
    std::cout << "Witaj, wiecie!\n";
}
---------------
std::cout << "Witaj, wiecie!\n";
---------------
#include <iostream>
using namespace std;           // dziki temu nazwy z std s widoczne bez przedrostka std:: (2.4.2)

double square(double x)        // podnosi do kwadratu liczb zmiennoprzecinkow o podwjnej precyzji
{
    return x*x;
}

void print_square(double x)
{
    cout << "Kwadrat liczby " << x << " wynosi " << square(x) << "\n";
}

int main()
{
    print_square(1.234); // drukuje wynik: Kwadrat liczby 1.234 wynosi 1.52276
}
---------------
int inch;
---------------
bool     // typ logiczny, ktrego zbir wartoci zawiera tylko prawd i fasz
char     // znak, np. 'a', 'z', '9'
int      // liczba cakowita, np. 1, 42, 1066
double   // liczba zmiennoprzecinkowa o podwjnej precyzji, np. 3.14 albo 299793.0
---------------
x+y   // plus
+x    // jednoargumentowy plus
x-y   // minus
-x    // jednoargumentowy minus
x*y   // mnoenie
x/y   // dzielenie
x%y   // reszta z dzielenia (modulo) liczb cakowitych
---------------
x==y     // rwny
x!=y     // rny
x<y      // mniejszy ni
x>y      // wikszy ni
x<=y     // mniejszy ni lub rwny
x>=y     // wikszy ni lub rwny
---------------
void jaka_funkcja() // funkcja nie zwracajca wartoci
{
    double d = 2.2;  // inicjacja liczby zmiennoprzecinkowej
    int i = 7;       // inicjacja liczby cakowitej
    d = d+i;         // przypisanie sumy do d
    i=d*i;           // przypisanie iloczynu do i (obcicie double d*i do int)
}
---------------
double d1 = 2.3;
double d2 {2.3};

complex<double> z = 1;        // liczba zespolona ze skalarami zmiennoprzecinkowymi o podwjnej precyzji
complex<double> z2 {d1,d2};
complex<double> z3 = {1,2};   // znak = nie jest obowizkowy w notacji { ... }
vector<int> v {1,2,3,4,5,6};  // wektor liczb typu int
---------------
int i1 = 7.2;   // i1 ma warto 7
int i2 {7.2};   // bd: konwersja liczby zmiennoprzecinkowej na cakowit
int i3 = {7.2}; // bd: konwersja liczby zmiennoprzecinkowej na cakowit (znak = jest niepotrzebny)
---------------
auto b = true;    // bool
auto ch = 'x';    // char
auto i = 123;     // int
auto d = 1.2;     // double
auto z = sqrt(y); // z jest typu zwracanego przez sqrt(y)
---------------
x+=y  // x = x+y
++x   // inkrementacja: x = x+1
x-=y  // x = x-y
--x   // dekrementacja: x = x-1
x*=y  // skalowanie: x = x*y
x/=y  // skalowanie: x = x/y
x%=y  // x = x%y
---------------
const int dmv = 17;                      // dmv jest nazwan sta
int var = 17;                            // var nie jest sta
constexpr double max1 = 1.4*square(dmv); // w porzdku, jeli square(17) jest wyraeniem staym
constexpr double max2 = 1.4*square(var); // bd: var nie jest wyraeniem staym
const double max3 = 1.4*square(var);     // w porzdku, mona to obliczy w czasie dziaania programu
double sum(const vector<double>&);       // funkcja sum nie zmodyfikuje swojego argumentu (2.2.5)
vector<double> v {1.2, 3.4, 4.5};        // v nie jest sta
const double s1 = sum(v);                // w porzdku: obliczanie w czasie dziaania programu
constexpr double s2 = sum(v);            // bd: sum(v) nie jest wyraeniem staym
---------------
constexpr double square(double x) { return x*x; }
---------------
bool accept()
{
    cout << "Czy chcesz kontynuowa (t lub n)?\n"; // wydrukowanie pytania

    char answer = 0;
    cin >> answer;                                 // wczytanie odpowiedzi

    if (answer == 't') return true;
    return false;
}
---------------
bool accept2()
{
    cout << "Czy chcesz kontynuowa (t lub n)?\n"; // wydrukowanie pytania

    char answer = 0;
    cin >> answer;                                 // wczytanie odpowiedzi

    switch (answer) {
    case 't':
        return true;
    case 'n':
        return false;
    default:
        cout << "Chyba raczej nie.\n";
        return false;
    }
}
---------------
bool accept3()
{
    int tries = 1;
    while (tries<4) {
        cout << "Czy chcesz kontynuowa (t lub n)?\n"; // wydrukowanie pytania
        char answer = 0;
        cin >> answer;                                 // wczytanie odpowiedzi

        switch (answer) {
        case 't':
            return true;
        case 'n':
            return false;
        default:
            cout << "Niestety, nie zrozumiaem.\n";
            ++tries; // inkrementacja
        }
    }
    cout << "Chyba raczej nie.\n";
    return false;
}
---------------
char v[6]; // tablica 6 znakw
---------------
char*p;    // wskanik na znak
---------------
char*p = &v[3]; // p wskazuje na czwarty element tablicy v
char x =*p;     // *p jest obiektem, na ktry wskazuje p
---------------
void copy_fct()
{
    int v1[10] = {0,1,2,3,4,5,6,7,8,9};
    int v2[10];                // bdzie kopi v1

    for (auto i=0; i!=10; ++i) // kopiowanie elementw
        v2[i]=v1[i];
    //...
}
---------------
void print()
{
    int v[] = {0,1,2,3,4,5,6,7,8,9};

    for (auto x : v) // dla kadego x w v
        cout << x << '\n';

    for (auto x : {10,21,32,43,54,65})
        cout << x << '\n';
    //...
}
---------------
void increment()
{
    int v[] = {0,1,2,3,4,5,6,7,8,9};

    for (auto& x : v)
        ++x;
    //...
}
---------------
T a[n]; // T[n]: tablica n obiektw typu T (7.3)
T*p;    // T*: wskanik na T (7.2)
T& r;   // T&: referencja do T (7.7)
T f(A); // T(A): funkcja przyjmujca argument typu A i zwracajca wynik typu T (2.2.1)
---------------
double*pd = nullptr;
Link<Record>*lst = nullptr; // wskanik do cza do rekordu
int x = nullptr;            // bd: nullptr jest wskanikiem, nie liczb cakowit
---------------
int count_x(char*p, char x)
    // liczy, ile razy x wystpuje w p[]
    // p powinien wskazywa zakoczon zerem tablic elementw typu char (albo nic)
{
    if (p==nullptr) return 0;
    int count = 0;
    for (;*p!=0; ++p)
        if (*p==x)
            ++count;
    return count;
}
---------------
struct Vector {
    int sz;       // liczba elementw
    double* elem; // wskanik do elementw
};
---------------
Vector v;
---------------
void vector_init(Vector& v, int s)
{
    v.elem = new double[s]; // alokacja tablicy s liczb typu double
    v.sz = s;
}
---------------
double read_and_sum(int s)
    // wczytuje s liczb cakowitych z cin i zwraca ich sum; s powinien mie warto dodatni
{
    Vector v;
    vector_init(v,s);   // alokacja s elementw dla v
    for (int i=0; i!=s; ++i)
        cin>>v.elem[i]; // wczytanie do elementw

    double sum = 0;
    for (int i=0; i!=s; ++i)
        sum+=v.elem[i]; // obliczenie sumy elementw
    return sum;
}
---------------
void f(Vector v, Vector& rv, Vector*pv)
{
    int i1 = v.sz;   // dostp poprzez nazw
    int i2 = rv.sz;  // dostp poprzez referencj
    int i4 = pv->sz; // dostp poprzez wskanik
}
---------------
class Vector {
public:
    Vector(int s) :elem{new double[s]}, sz{s} { } // konstrukcja wektora
    double& operator[](int i) { return elem[i]; } // dostp do elementu: indeksowanie
    int size() { return sz; }
private:
    double*elem; // wskanik do elementw
    int sz;      // liczba elementw
};
---------------
Vector v(6); // Vector z szecioma elementami
---------------
double read_and_sum(int s)
{
    Vector v(s);   // utworzenie wektora s elementw
    for (int i=0; i!=v.siz e(); ++i)
        cin>>v[i]; // wczytanie do elementw

    double sum = 0;
    for (int i=0; i!=v.siz e(); ++i)
        sum+=v[i]; // obliczenie sumy elementw
    return sum;
}
---------------
:elem{new double[s]}, sz{s}
---------------
enum class Color { czerwony, niebieski , zielony };
enum class Traffic_light { zielony, ty, czerwony };
Color col = Color::czerwony;
Traffic_light light = Traffic_light::czerwony;
---------------
Color x = czerwony;                // bd: o ktry czerwony chodzi?
Color y = Traffic_light::czerwony; // bd: ten czerwony nie naley do Color
Color z = Color::czerwony;         // OK
---------------
int i = Color::czerwony;           // bd: Color::czerwony nie jest typem int
Color c = 2;                       // bd: 2 to nie kolor
---------------
Traffic_light& operator++(Traffic_light& t)
    // przedrostkowa inkrementacja: ++
{
    switch (t) {
    case Traffic_light::green: return t=Traffic_light::yellow;
    case Traffic_light::yellow: return t=Traffic_light::red;
    case Traffic_light::red: return t=Traffic_light::green;
    }
}

Traffic_light next = ++light; // next bdzie Traffic_light::green
---------------
double sqrt(double); // funkcja obliczajca pierwiastek kwadratowy, pobierajca i zwracajca double

class Vector {
public:
    Vector(int s);
    double& operator[](int i);
    int size();
private:
    double*elem; // elem wskazuje tablic sz wartoci typu doubles
    int sz;
};
---------------
double sqrt(double d) // definicja funkcji sqrt()
{
    //... taki sam algorytm, jaki mona znale w podrcznikach do matematyki...
}
---------------
Vector::Vector(int s)             // definicja konstruktora
    :elem{new double[s]}, sz{s}   // inicjacja skadowych
{
}
double& Vector::operator[](int i) // definicja indeksowania
{
    return elem[i];
}
int Vector::size()                // definicja funkcji size()
{
    return sz;
}
---------------
// Vector.h:

class Vector {
public:
    Vector(int s);
    double& operator[](int i);
    int size();
private:
    double*elem; // elem wskazuje tablic sz liczb typu double
    int sz;
};
---------------
// user.cpp:
#include "Vector.h"  // pobranie interfejsu wektora
#include <cmath>     // pobranie interfejsu funkcji matematycznych biblioteki standardowej, m.in. sqrt()
using namespace std; // ustawienie widocznoci skadnikw przestrzeni nazw std (2.4.2)
double sqrt_sum(Vector& v)
{
    double sum = 0;
    for (int i=0; i!=v.siz e(); ++i)
        sum+=sqr t(v[i]); // suma pierwiastkw kwadratowych
    return sum;
}
---------------
// Vector.cpp:

#include "Vector.h" // pobranie interfejsu

Vector::Vector(int s)
    :elem{new double[s]}, sz{s}
{
}

double& Vector::operator[](int i)
{
    return elem[i];
}

int Vector::siz e()
{
    return sz;
}
---------------
namespace My_code {
    class complex { /*...*/ };
    complex sqr t(complex);
    //...
    int main();
}

int My_code::main()
{
    complex z {1,2};
    auto z2 = sqrt(z);
    std::cout << '{' << z2.real() << ',' << z2.imag() << "}\n";
    //...
};

int main()
{
    return My_code::main();
}
---------------
using namespace std;
---------------
double& Vector::operator[](int i)
{
    if (i<0 || size()<=i) throw out_of_rang e{"Vector::operator[]"};
    return elem[i];
}
---------------
void f(Vector& v)
{
    //...
    try{ // wyjtki wystpujce w tym miejscu s obsugiwane przez procedur, ktrej definicja znajduje si poniej

        v[v.size()] = 7; // prba dostpu do elementu poza struktur v
    }
    catch (out_of_range) { // ups: bd out_of_range
        // ... obsuga bdu zakresu...
    }
    //...
}
---------------
Vector v(-27);
---------------
Vector::Vector(int s)
{
    if (s<0) throw length_error{};
    elem = new double[s];
    sz = s;
}
---------------
void test()
{
    try{
        Vector v(-27);
    }
    catch (std::length_error) {
        // obsuga ujemnych rozmiarw
    }
    catch (std::bad_alloc) {
        // obsuga wyczerpania pamici
    }
}
---------------
static_assert(4<=sizeof(int), "Typ int jest za may"); // sprawdza rozmiar typu int
---------------
constexpr double C = 299792.458;                              // km/s

void f(double speed)
{
    const double local_max = 160.0/(60*60);                   // 160 km/h == 160.0/(60*60) km/s

    static_assert(speed<C,"Nie mona tak szybko jecha");     // bd: szybko musi by sta
    static_assert(local_max<C,"Nie mona tak szybko jecha"); // OK
    //...
}



