14.cpp

Go to the documentation of this file.

 
static_assert(__cplusplus == 201402, "");
 
#include <bits/stdc++.h>
 
using namespace std;
 
#define static_assert(a) static_assert(a, "")
static_assert(__cpp_return_type_deduction);
 
auto implicit_int_return_type()
{
    return 1;
}
 
// template <typename T> T before_deduced_return_type(int a) { return a; }
auto deduced_return_type(int a)
{
    return a;
}
 
// template <typename T> T& before_deduced_return_type_template(T& a) { return a; }
template <typename T> auto& deduced_return_type_template(T& t)
{
    return t;
}
 
// Returns a reference to a deduced type.
auto deduced_return_type_lambda = [](auto& x) -> auto& {
    return deduced_return_type_template(x);
};
 
void return_type_deduction_demo()
{
    implicit_int_return_type();
    auto x = deduced_return_type(1);
    int& y = deduced_return_type_lambda(x); // reference to `x`
    assert(&y == &x);
    assert(y == 1);
}
 
 
 
 
static_assert(__cpp_variable_templates);
 
template<typename T>
T pi = T(3.141592653589793238462643383);
 
// String pi
// Usual specialization rules apply:
template<>
const char* pi<const char*> = "pi";
 
static void demo()
{
    assert(pi<int> == 3);
    assert(string(pi<const char*>) == "pi");
 
    auto binary_literal = 0b0100'1100'0110;
 
    auto integer_literal = 1'000'000;
 
    auto floating_point_literal = 0.000'015'3;
 
 
    auto str = "hello world"s; // auto deduces string
    auto dur = 60s;            // auto deduces chrono::seconds
 
}
 
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>());
 
    // Tuple addressing via type
    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);
 
    // https://en.cppreference.com/w/cpp/language/auto
    int a = 0;
    static_assert(__cpp_decltype_auto);
    decltype(auto) a_copy = a;
    assert(&a_copy != &a);
    decltype(auto) a_ref = (a);
    assert(&a_ref == &a);
 
    // https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
    //auto u = unique_ptr<int>(new int(1));
    auto u = make_unique<int>(1);
    assert(u);
    assert(*u == 1);
    auto ua = make_unique<int[]>(3);
}
 
 
static void lambda_14()
{
    // Generic lambdas
    // auto before_generic_lambda = [](int x) { return x; };
    static_assert(__cpp_generic_lambdas);
    auto generic_lambda = [](auto x) { return x; };
 
    auto universal_size = [](const auto& m) { return m.size(); };
 
    static_assert(__cpp_init_captures);
    auto capture_initializers = [value = 1] { return value; };
 
    assert(capture_initializers() == 1);
 
    auto mutable_lambda = [value = 1] () mutable { return ++value; };
 
    assert(mutable_lambda() == 2);
    assert(mutable_lambda() == 3);
 
    // capture initialization can change context
    int c = 0;
    auto change_c = [value = ++c] { };
    assert(c == 1);
 
    unique_ptr<int> ptr(new int(10));
    auto capture_by_move = [value = 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; }
         );
}
 
 
int main(void)
{
    return_type_deduction_demo();
    demo();
    sort_14();
    types_14();
    lambda_14();
}