20.cpp

Go to the documentation of this file.

 
static_assert(__cplusplus >= 201707);
 
#include <bits/stdc++.h>
 
using namespace std;
 
#if __cpp_lib_three_way_comparison
static_assert(1 <=> 2 < 0 );
static_assert(2 <=> 1 > 0 );
static_assert(1 <=> 1 == 0 );
#else
#pragma message("undefined __cpp_lib_three_way_comparison")
#endif
 
#if __cpp_char8_t
char8_t char8;
#endif
 
 
auto to_array_demo = to_array("foo");
static_assert(to_array_demo.size() == 4);
 
void init_20()
{
    struct point { int x, y; };
    struct line { point a, b; };
 
    // [aggregate_initialization](https://en.cppreference.com/w/cpp/language/aggregate_initialization)
 
#if __cplusplus > 201707
    point p1 = { .x = 1 };
    assert(p1.x == 1);
    assert(!p1.y);
 
    point p2 { {} , 2 };
    assert(p2.y == 2);
    assert(!p2.x);
#endif
#if __cpp_aggregate_paren_init >= 201902
    int a[] (0, 1, 2);
    assert(a[2] == 2);
    line l2 = { 1, 2 };
    assert(l2.a.x == 1);
    assert(l2.a.y == 2);
#endif
    line l1 = { };
    assert(!l1.a.x);
    line l3 = { 1, 2, 3, 4 };
    assert(l3.b.x == 3);
    assert(l3.b.y == 4);
}
 
void types_20()
{
#if __cpp_lib_bit_cast
    cout << typeid(bit_cast<double>(0));
#endif
}
 
void dynamic_memory_20()
{
    auto a = make_shared<int[10]>();
    static_assert(is_same_v<decltype(a.get()), int*>);
 
    map<int, int> m = {{2,3}};
#if __cplusplus > 201707 && __GNUG__ > 8
    assert(m.contains(2));
#endif
#if __cpp_lib_erase_if
    vector<int> v = {11, 12, 13};
    assert(erase_if(v, [](int a) {return a >= 13;}) == 1);
    assert(v.size() == 2);
#endif
}
 
namespace lambda {
 
#if __cpp_template_template_args && __GNUG__ > 8
template <typename ... Args>
auto make_lambda_with_parameter_pack_capture(Args&& ... args)
{
    return [... args = forward<Args>(args)] {
        return (... + args);
    };
}
#endif
 
void lambda_20()
{
#if __cplusplus >= 201709
    // generic lambda, operator() is a template with two parameters
    auto glambda = []<class T>(T a, auto&& b) { return a < b; };
    assert(glambda(1,2));
    // generic lambda, operator() is a template with one parameter pack
    auto f = []<typename ...Ts>(Ts&& ...ts) {
        return 1;
    };
    assert(f(1,2,3));
 
    struct point { int x, y; };
    auto point_lambda = []<class T=point>(T&& var) {};
    point_lambda({1, 2});
 
    #if __cpp_template_template_args && __GNUG__ > 8
    assert(make_lambda_with_parameter_pack_capture(1,2,3)() ==  6);
    #endif
#endif
}
 
}
using namespace lambda;
 
 
 
// Using [requires](https://en.cppreference.com/w/cpp/keyword/requires)
 
template <typename T> requires is_integral_v<T> T constexpr requires_demo(T a) { return a + 1; }
 
static_assert(requires_demo(1) == 2);
 
template <typename T> auto constexpr requires_demo(T && a) requires is_same_v<T, double> { return 2; }
static_assert(requires_demo(0.1) == 2);
 
// Annotated example of complex requirement
template <class T>
requires // requires-clause
is_signed_v<T> || (is_unsigned_v<T> && ! is_void_v<void>) // constraint expression
void complex_requirement_demo() { }
 
 
template < class T >
requires  // requires-clause
requires() // requires-expression
{ true;} // unevaluated requirements sequence
void requires_expression_demo() { }