---------------
using namespace std::chrono;
---------------
steady_clock::time_point t = steady_clock::now();
//... jakie dziaania...
steady_clock::duration d = steady_clock::now()-t;  // zrobienie czego zajo d jednostek czasu
---------------
auto t = steady_clock::now();
//... jakie czynnoci...
auto d = steady_clock::now()-t;  // zrobienie czego zajo d jednostek czasu
cout << "zrobienie czego zajo" << duration_cast<milliseconds>(d).count() 
(<< " ms"; // drukuje liczb milisekund
---------------
template<typename Rep, typename Period = ratio<1>>
class duration {
public:
    using rep = Rep;
    using period = Period;
    //...
};
---------------
duration<long long,milli> d1 {7}; // 7 milisekund
duration<double,pico> d2 {3.33};  // 3,33 pikosekundy
duration<int,ratio<1,1>> d3 {};   // 0 sekund
---------------
cout << d1.count() << '\n';       // 7
cout << d2.count() << '\n';       // 3.33
cout << d3.count() << '\n';       // 0
---------------
d2=d1;
cout << d1.count() << '\n';       // 7
cout << d2.count() << '\n';       // 7e+009
if (d1!=d2) cerr<<"szalestwo!";
---------------
duration<int, milli> d {3};       // OK
duration<int, milli> d {3.5};     // bd: konwersja 3,5 na int oznacza zawenie
duration<int, milli> ms {3};
duration<int, micro> us {ms};     // OK
duration<int, milli> ms2 {us};    // bd: moglibymy straci wiele mikrosekund
---------------
duration<long long,milli> d1 {7}; // 7 milisekund
d1 += 5; // bd
duration<int,ratio<1,1>> d2 {7};  // 7 sekund
d2 = 5; // bd
d2 += 5; // bd
---------------
d1 += duration<long long,milli>{5}; // OK: milisekundy
d3 += decltype(d2){5};              // OK: sekundy
---------------
using nanoseconds = duration<si64,nano>;
using microseconds = duration<si55,micro>;
using milliseconds = duration<si45,milli>;
using seconds = duration<si35>;
using minutes = duration<si29,ratio<60>>;
using hours = duration<si23,ratio<3600>>;
---------------
auto t1 = system_clock::now();
f(x); // robi co
auto t2 = system_clock::now();

auto dms = duration_cast<milliseconds>(t2-t1);
cout << "Wykonanie funkcji f(x) zajo " << dms.count() << " milisekund\n";

auto ds = duration_cast<seconds>(t2-t1);
cout << "Wykonanie funkcji f(x) zajo " << ds.count() << " sekund\n";
---------------
auto t1 = system_clock::now();
f(x); // robi co
auto t2 = system_clock::now();

cout << "Wykonanie funkcji f(x) zajo " << milliseconds(t2-t1).count() << " 
(milisekund\n"; // bd: obcicie
cout << "Wykonanie funkcji f(x) zajo " << microseconds(t2-t1).count() << " 
(mikrosekund\n";
---------------
template<typename Clock, typename Duration = typename Clock::duration>
class time_point {
public:
    using clock = Clock;
    using duration = Duration;
    using rep = typename duration::rep;
    using period = typename duration::period;
    //...
};
---------------
void test()
{
    time_point<steady_clock,milliseconds> tp1(milliseconds(100));
    time_point<steady_clock,microseconds> tp2(microseconds(100*1000));

    tp1=tp2; // bd: oznaczaoby obcicie
    tp2=tp1; // OK
    if (tp1!=tp2) cerr << "Szalestwo!";
}

---------------
void test2()
{
    auto tp = steady_clock::now();
    auto d1 = time_point_cast<hours>(tp).time_since_epoch().count()/24; // liczba dni od pocztku epoki

    using days = duration<long,ratio<24*60*60,1>>;                      // dugo dnia
    auto d2 = time_point_cast<days>(tp).time_since_epoch().count();     // liczba dni od pocztku epoki

    if (d1!=d2) cout << "Niemoliwe!\n";
}
---------------
class system_clock {
public:
    using rep = /* zdefiniowany przez implementacj typ ze znakiem */;
    using period = /* zdefiniowany przez implementacj ratio<> */;
    using duration = chrono::duration<rep,period>;
    using time_point = chrono::time_point<system_clock>;
    //...
};

---------------
void test3()
{
    auto t1 = system_clock::now();
    f(x); // robi co
    auto t2 = system_clock::now();
    cout << "Wykonanie funkcji f(x) zajo " << duration_cast<milliseconds>(t2-t1).count() << " ms";
}

---------------
cout << "min " << system_clock::duration::min().count()
     << ", maks " << system_clock::duration::max().count()
     << ", " << (treat_as_floating_point<system_clock::duration>::value ? "ZP" : 
     ("cakowitoliczbowy") << '\n';

cout << (system_clock::is_steady?"steady\n": "nie steady\n");
---------------
min -9223372036854775808, maks 9223372036854775807, cakowitoliczbowy
nie steady
---------------
template<typename Rep>
struct treat_as_floating_point : is_floating<Rep> { };

---------------
template<typename Rep1, typename P1, typename Rep2, typename P2>
struct common_type<duration<Rep1,P1>, duration<Rep2, P2>> {
    using type = duration<typename common_type<Rep1,Rep2>::type, GCD<P1,P2>>;
};
---------------
template<typename Clock, typename Duration1, typename Duration2>
struct common_type<time_point<Clock, Duration1>, time_point<Clock, Duration2>> {
    using type = time_point<Clock, typename common_type<Duration1, Duration2>::type>;
};
---------------
template<intmax_t N, intmax_t D = 1>
struct ratio {
    static constexpr intmax_t num = N;
    static constexpr intmax_t den = D;

    using type = ratio<num,den>;
};

---------------
static_assert(ratio_add<ratio<1,3>, ratio<1,6>>::num == 1, "problem: 1/3+1/6 != 1/2");
static_assert(ratio_add<ratio<1,3>, ratio<1,6>>::den == 2, "problem: 1/3+1/6 != 1/2");
static_assert(ratio_multiply<ratio<1,3>, ratio<3,2>>::num == 1, "problem: 1/3*3/2 != 1/2");
static_assert(ratio_multiply<ratio<1,3>, ratio<3,2>>::den == 2, "problem: 1/3*3/2 != 1/2");
---------------
using yocto  = ratio<1,1000000000000000000000000>;  // obsugiwane warunkowo
using zepto  = ratio<1,1000000000000000000000>;     // obsugiwane warunkowo
using atto = ratio<1,1000000000000000000>;
using femto  = ratio<1,1000000000000000>;
using pico = ratio<1,1000000000000>;
using nano = ratio<1,1000000000>;
using micro = ratio<1,1000000>;
using milli = ratio<1,1000>;
using centi = ratio<1,100>;
using deci = ratio<1,10>;
using deca = ratio<10,1>;
using hecto = ratio<100,1>;
using kilo = ratio<1000,1>;
using mega = ratio<1000000,1>;
using giga = ratio<1000000000,1>;
using tera = ratio<1000000000000,1>;
using peta = ratio<1000000000000000,1>;
using exa  = ratio<1000000000000000000,1>;
using zetta  = ratio<1000000000000000000000,1>;     // obsugiwane warunkowo
using yotta  = ratio<1000000000000000000000000,1>;  // obsugiwane warunkowo
---------------
template<typename T>
void f(T& a)
{
    static_assert(std::is_floating_point<T>::value ,"Oczekiwano typu 
    (zmiennoprzecinkowego");
    //...
}
---------------
template<typename T>
constexpr bool Is_floating_point<T>()
{
    return std::is_floating_point<T>::value;
}

template<typename T>
void f(T& a)
{
    static_assert(Is_floating_point<T>(),"Oczekiwano typu zmiennoprzecinkowego");
    //...
}
---------------
template<typename T>
class Cont {
    T* elem;   // przechowuje elementy w tablicy wskazywanej przez elem
    size_t sz; // sz elementw
    //...
    Cont(const Cont& a) // konstruktor kopiujcy
        :elem{new T[a.sz]}, sz{a.sz}
    {
        static_assert(Is_copy_constructable<T>(),"Cont::Cont(): brak kopiowania");
        if (Is_trivially_copyable<T>())
            memcpy(elem,a.elem,sz*sizeof(T)); // optymalizacja kopiowania pamici
        else
            uninitialized_copy(a.begin(),a.end(),elem); // uycie konstruktorw kopiujcych
    }
    //...
}
---------------
class X {
public:
    void inside();
private:
    X& operator=(const X&);
    ~X();
};

void X::inside()
{
    cout << "inside =: " << is_copy_assignable<X>::value << '\n';
    cout << "inside ~: " << is_destructible<X>::value << '\n';
}

void outside()
{
    cout << "outside =: " << is_copy_assignable<X>::value << '\n';
    cout << "outside ~: " << is_destructible<X>::value << '\n';
}

---------------
template<typename T>
Cont::~Cont() // destruktor kontenera Cont
{
    if (!Is_trivially_destructible<T>())
        for (T* p = elem; p!=elem+sz; ++p)
            p->~T();
}

---------------
template<typename T>
void f(T a)
{
    static_assert(Is_array<T>(), "f(): nie tablica");
    constexpr int dn {Extent<T,2>()};  // liczba elementw w drugim wymiarze (liczc od zera)
    //...
}

---------------
template<typename T>
void draw(T t)
{
    static_assert(Is_same<Shape*,T>() || Is_base_of<Shape,Remove_pointer<T>>(), "");
    t->draw();
}

---------------
template<typename K, typename V>
class My_map {
{
    pair<typename add_const<K>::type ,V> default_node;
    //...
};
---------------
template<typename T>
using Add_const = typename add_const<T>::type;

template<typename K, typename V>
class My_map {
{
    pair<Add_const<K>,V> default_node;
    //...
};

---------------
template<typename T>
void f(T v)
{
    Remove_reference<T> x = v; // kopiowanie v
    T y = v;                   // moe kopiowanie v, a moe referencja do v
    ++x;                       // inkrementacja zmiennej lokalnej
    ++y;
    //...
}
---------------
void user()
{
    int val = 7;
    f(val); // wywoanie f<int&>(): ++y w f() zwikszy warto val
    f(7);   // wywoanie f<int>(): ++y w f zwikszy lokaln kopi
}

---------------
int a[10][20];
Remove_extent<decltype(a)> a10; // array[10]
Remove_all_extents<decltype(a)> i; // int

---------------
template<typename T>
void f(T x)
{
    Add_pointer<T> p = new Remove_reference<T>{};
    T* p = new T{};  // nie zadziaa, jeli T bdzie referencj
    //...
}

---------------
template<std::size_t N, std::size_t A>
struct aligned_storage {
    using type = struct { alignas(A) unsigned char data[N]; }; // N znakw wyrwnanych do A (6.2.9)
};

---------------
template<typename...T>
struct common_type;

template<typename T>
struct common_type<T> {
    using type = T;
};
---------------
template<typename T, typename U>
struct common_type<T, U> {
    using type = decltype(true ? declval<T>() : declval<U>());
};
---------------
template<typename T, typename U, typename... V>
struct common_type<T, U, V...> {
    using type = typename common_type<typename common_type<T, U>::type, V...>::type;
};
---------------
template<typename T, typename U>
using Common_type = typename common_type<T,U>::type;

Common_type<int,double> x1;               // x1 to double
Common_type<int,string> x2;               // bd: brak wsplnego typu
Common_type<int,short,long,long long> x3; // x3 to long long
Common_type<Shape*,Circle*> x4;           // x4 to Shape*
Common_type<void*,double*,Shape*> x5;     // x5 to void*
---------------
int ff(int) { return 2; } // funkcja

typedef bool (*PF)(int);  // wskanik do funkcji

struct Fct {              // obiekt funkcyjny
    double operator()(string);
    string operator()(int,int);
};

auto fx = [](char ch) { return tolower(ch); }; // lambda

Result_of<decltype(&ff)()> r1 = 7;      // r1 to int
Result_of<PF(int)> r2 = true;           // r2 to bool
Result_of<Fct(string)> r3 = 9.9;        // r3 to double
Result_of<Fct(int,int)> r4 = "Hero";    // r4 to string
Result_of<decltype(fx)(char)> r5 = 'a'; // r5 to char
---------------
int f();                          // funkcja
string f(int);
Result_of<decltype(&f)()> r1 = 7; // bd: brak rozstrzygania przecie dla wskanika do funkcji
---------------
Result_of<ff> r1 = 7;             // bd: brak specyfikacji argumentu
                                  // i ff jest funkcj, a nie typem

Result_of<ff()> r1 = 7;           // bd: argument do Result_of musi by typem
Result_of<decltype(f)()> r2 = 7;  // bd: decltype(f) jest typem funkcji,
                                  // nie wskanikiem na typ funkcji
Result_of<decltype(f)*()> r3 = 7; // OK: r3 to int
---------------
template<typename F, typename A>
auto temp(F f, A a) -> Result_of<F(A)>
{
    //...
}

void f4()
{
    temp(ff,1);
    temp(fx,'a');
    temp(Fct(),"Ulysses");
}

---------------
template<typename T, size_t N>
void array<T,N>::swap(array& a) noexcept(noexcept(swap(declval<T&>(), declval<T&>())))
{
    for (int i=0; i<a.size(); ++i)
        swap((*this)[i],a[i]);
}

---------------
template<typename T>
Remove_reference<T>&& move(T&& t) noexcept
{
    return static_cast<Remove_reference<T>&&>(t);
}
---------------
template<typename T>
T&& forward(Remove_reference<T>& t) noexcept
{
    return static_cast<T&&>(t);
}

template<typename T>
T&& forward(Remove_reference<T>&& t) noexcept;
{
    static_asser t(!Is_lvalue_reference<T>,"przekazanie wartoci lewostronnej");
    return static_cast<T&&>(t);
}
---------------
int i = 7;
forward(i); // wywoanie pierwszej wersji
forward(7); // wywoanie drugiej wersji

---------------
template<typename T>
void swap(T& a, T& b) noexcept(Is_nothrow_move_constructible<T>()
                          && Is_nothrow_move_assignable<T>())
{
    T tmp {move(a)};
    a = move(b);
    b = move(tmp);
}
---------------
vector<int> v {1,2,3,4};
swap(v,vector<int>{}); // bd: drugi argument jest wartoci prawostronn
v.clear();             // janiejsze

---------------
struct Val {
    double d;
    bool operator==(Val v) const { return v.d==d; }
};

void my_algo(vector<Val>& vv)
{
    using namespace std::rel_ops;

    for (int i=0; i<vv.size(); ++i)
        if (0>vv[i]) // OK: > z rel_ops
            vv[i]=abs(vv[i]);
}
---------------
namespace Mine {
    struct Val {
        double d;
        bool operator==(Val v) const { return v.d==d; }
    };

    using namespace std::rel_ops;
}

---------------
unordered_map<type_index,type_info*> types;
//...
types[type_index{something}] = &typeid(something);