14.cpp

/**
 @file
 @brief C++14
 @defgroup CPP14 C++14 examples

 https://en.wikipedia.org/wiki/C++14

 https://isocpp.org/wiki/faq/cpp14-language

 https://github.com/AnthonyCalandra/modern-cpp-features/blob/master/CPP14.md

 @{
*/

static_assert(__cplusplus == 201402, "");

#include<bits/stdc++.h>

usingnamespacestd;

/**
 @defgroup ded14 Deduction
 @{
*/

#definestatic_assert(a) static_assert(a, "")
static_assert(__cpp_return_type_deduction);

autoimplicit_int_return_type()
{
return1;
}

// template <typename T> T before_deduced_return_type(int a) { return a; }
autodeduced_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&
{
returndeduced_return_type_template(x);
};

voidreturn_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);
}

/// @}
/**
 @defgroup other14 Other
 @{
 TODO:

 https://en.cppreference.com/w/cpp/container/map/find

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

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

 https://en.cppreference.com/w/cpp/language/function // decltype(auto)

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

 https://en.cppreference.com/w/cpp/thread/shared_timed_mutex

 https://en.cppreference.com/w/cpp/thread/shared_lock

 https://en.cppreference.com/w/cpp/utility/integer_sequence

 https://en.cppreference.com/w/cpp/utility/exchange

 https://en.cppreference.com/w/cpp/utility/forward

 https://en.cppreference.com/w/cpp/io/manip/quoted

 // [[deprecated]]
*/

/// Binary literals, digit separators

/// Template variables
/// https://en.cppreference.com/w/cpp/language/variable_template

static_assert(__cpp_variable_templates);

/// Numeric pi
template <typename T>
T pi = T(3.141592653589793238462643383);

// String pi
// Usual specialization rules apply:
template <>
constchar* pi<constchar*> = "pi";

staticvoiddemo()
{
assert(pi<int> == 3);
assert(string(pi<constchar*>) == "pi");

auto binary_literal = 0b0100'1100'0110;

auto integer_literal = 1'000'000;

auto floating_point_literal = 0.000'015'3;

/// Standard user-defined literals

auto str = "hello world"s; // auto deduces string
auto dur = 60s; // auto deduces chrono::seconds
}

voidtypes_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);
}

/// @}
/**
 @defgroup lambda14 Lambda
 https://en.cppreference.com/w/cpp/language/lambda
 @{
*/
staticvoidlambda_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 = [](constauto& 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(newint(10));
auto capture_by_move = [value = move(ptr)] { return *value; };
}

/// Compare with @ref lambda::sort_11

voidsort_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) // C++14 allows auto
 { return a > b; });

// https://stackoverflow.com/questions/18045208/override-mapcompare-with-lambda-function-directly
auto reverse = map<string, int, function<bool(const string&, const string&)>> {
 [](constauto& a, constauto& b) { return a > b; }
 }
 = {
 { "a", 2 },
 { "b", 1 },
 { "c", 0 },
 };
assert(reverse.begin()->first == "c");
assert(reverse.begin()->second == 0);
}

/// @}

intmain(void)
{
return_type_deduction_demo();
demo();
sort_14();
types_14();
lambda_14();
}
/// @}