{

tuple<string, string, int> tuple_by_type("foo", "bar", 7);

int i = get<int>(tuple_by_type);

assert(i == 7);

int j = get<2>(tuple_by_type);

assert(j == 7);

{

assert(pi<int> == 3);

assert(string(pi<const char*>) == "pi");

{

// https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique

auto u = make_unique<int>(1);

assert(u);

assert(*u == 1);

static void lambda_14()

{

// Generic lambdas

// auto before_generic_lambda = [](int x) { return x; };

auto generic_lambda = [](auto x) { return x; };

auto universal_size = [](const auto& m) { return m.size(); };

auto capture_initializers = [value = 1] { return value; };

assert(capture_initializers() == 1);

auto mutable_lambda = [value = 1] () mutable { return ++value; };

assert(mutable_lambda() == 2);

unique_ptr<int> ptr(new int(10));

auto capture_by_move = [value = std::move(ptr)] { return *value; };

}

void sort_14()

{

array<int, 10> s = {5, 7, 4, 2, 8, 6, 1, 9, 0, 3};

sort(s.begin(), s.end(),

// sort using a generic lambda expression

[](auto a, auto b)

{ return a > b; }

);

}

void types_14()

{

static_assert(is_null_pointer< decltype(nullptr) >::value);

static_assert(is_null_pointer< nullptr_t >::value);

static_assert(__cpp_decltype);

static_assert(is_integral<int>());

// https://en.cppreference.com/w/cpp/language/auto

int a = 0;

decltype(auto) a_copy = a;

assert(&a_copy != &a);

decltype(auto) a_ref = (a);

assert(&a_ref == &a);

}

int main(void)

{

auto x = deduced_return_type(1);

int& y = deduced_return_type_lambda(x); // reference to `x`

assert(&y == &x);

assert(y == 1);

tuple_demo();

template_variables::demo();

implicit_return_type();

dynamic_memory_14();

sort_14();

types_14();

lambda_14();

}