11.cpp

Go to the documentation of this file.

 
static_assert(__cplusplus == 201103, "");
 
#include <signal.h>
#include <unistd.h>
#include <bits/stdc++.h>
 
#if __has_include (<version>)
#include <version>
#endif
 
using namespace std;
 
void types_11()
{
    static_assert(__cpp_decltype, "");
 
    int a;
    // https://en.cppreference.com/w/cpp/header/type_traits
    decltype(a) b; // https://en.cppreference.com/w/cpp/language/decltype
 
    assert((is_same<decltype(a), decltype(b)>::value));
    assert((!is_same<decltype(a), unsigned>::value));
    assert((is_same<int, int32_t>::value));
    assert((is_same<signed, int32_t>::value));
 
    assert(is_integral<int>::value);
    assert(is_integral<bool>::value);
    assert(!is_integral<float>::value);
    assert(is_pointer<int*>::value);
    assert(sizeof (long long) >= 8);
}
 
 
void unique_pounter()
{
    int d = 0;
    unique_ptr<int> u1;
    assert(!u1);
    u1.reset(&d);
    assert(u1);
    *u1 = 1;
    assert(d == 1);
 
    unique_ptr<int> u2;
    // u2 = u1; - prohibited
 
    int * p1 = u1.get();
    u2 = move(u1); // [move](https://en.cppreference.com/w/cpp/utility/move)
    assert(u2.get() == p1);
    assert(u2);
    assert(!u1);
    assert(u2.get() == &d);
    // must release because d is local
    u2.release();
    u2.reset(new int(10));
    assert(*u2 == 10);
 
    u2.reset(); // deletes int(10)
    assert(u2 == nullptr); // [nullptr](https://en.cppreference.com/w/cpp/language/nullptr)
 
    assert(!u2);
}
 
 
void shared_pointer()
{
    shared_ptr<int> s1;
    assert(!s1);
    assert(!s1.use_count());
 
    auto s2 = make_shared<int>(1);
    assert(s2.use_count() == 1);
 
    s1 = s2;
    assert(s1.use_count() == 2);
 
    *s1 = 2;
    assert(*s1 == *s1.get());
    assert(*s2 == 2);
 
    s2 = nullptr; // like s2.reset();
    assert(s1.use_count() == 1);
    assert(!s2.use_count());
}
 
 
void weak_pointer()
{
    std::weak_ptr<int> wp;
 
    assert(!wp.lock());
    assert(!wp.use_count());
    auto sp = std::make_shared<int>(1);
    wp = sp;
    assert(*wp.lock() == 1);
}
 
void dynamic_memory_11()
{
    auto a = new int[3] {1, 2, 3};
    assert(a[2] == 3);
    delete[] a;
 
    auto as = new string[3] {"1", "2", "3"};
    assert(as[2] == "3");
    delete[] as; // calls destructors for all members
 
    unique_pounter();
 
    shared_pointer();
 
    weak_pointer();
}
 
 
char func_type(const int& x)
{
    assert(is_const<typename remove_reference<decltype(x)>::type>::value);
    assert(is_lvalue_reference<decltype(x)>::value);
    return 'C';
}
 
char func_type(int& x)
{
    assert(is_lvalue_reference<decltype(x)>::value);
    return 'L';
}
 
char func_type(int&& x)
{
    assert(is_rvalue_reference<decltype(x)>::value);
    return 'R';
}
 
 
template<class T>
char func_type_template(T&& x) // x is a forwarding reference
{
    // x is not R-value here
    assert(func_type(x) != 'R');
 
    // x can be forwarded as R or L value
    // https://en.cppreference.com/w/cpp/utility/forward
    return func_type(forward<T>(x)); // like func_type((T)(x));
}
 
void references_11()
{
    // https://en.cppreference.com/w/cpp/language/reference
    assert(is_reference<int&>::value);
 
    // L-value:
    assert(is_lvalue_reference<int&>::value);
 
    // R-value
    assert(is_rvalue_reference<int&&>::value);
 
    const int c = 1;
    int i = 2;
 
    assert(func_type(3) == 'R');
    assert(func_type(c) == 'C');
    assert(func_type(move(i)) == 'R');
 
    assert(func_type_template(c) == 'C');
    assert(func_type_template(i) == 'L');
    assert(func_type_template(3) == 'R');
    reference_wrapper<int> rw = i;
    rw.get() = 3;
    assert(i == 3);
    auto cr = cref(i);
    assert(cr == 3);
}
 
void init_11()
{
    struct C { int a, b, c; };
    auto o2 = C {1, 2, 3};
    C o3 {1, 2, 3};
    (void) o3;
 
    auto uses_il = [](initializer_list<int> il) {
        assert(*il.begin() == 3);
        assert(il.size() == 4);
    };
    uses_il({3, 2, 1, 0});
 
    auto z1 = C();
    C z2 = {};
    auto z3 = C {};
 
    assert(!z1.a);
    assert(!z2.a);
    assert(!z3.a);
    array<int, 3> a {1, 2};
}
 
auto auto_int = 1;
 
// int before(int a) { return a; }
auto trailing_return_type(int a) -> int
{
    return a;
}
 
 
void copy_elision_demo()
{
    struct Obj2 { Obj2* orig = this; int ballast[4]; };
    auto&& o2 = [](){ return Obj2();}();
    assert(&o2 == o2.orig);
}
 
void func_11()
{