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() { }
 
template <class T> requires requires(T a) { a / 0; } auto constexpr what(T a) { return 1; }
static_assert(what(1) == 1);
 
template <class T> requires requires(T a) { a[0]; } auto constexpr what(T a) { return 2; }
static_assert(what("2") == 2);
 
 
template <typename T> concept truism = true;
 
#if !__cpp_lib_concepts
 
template <class T> concept integral = is_integral_v<T>;
 
#endif
 
template <class T> concept integral_req_ct = requires (T a) { is_integral_v<T>; };
 
template <integral_req_ct T> constexpr T _inc2(T a) { return a + 1; }
 
static_assert(_inc2(1) == 2);
 
template<typename T> concept compound_requirements =
requires(T x) {
    {x + 1} -> convertible_to<bool>;
    {x * 2} -> same_as<int>;
};
 
 
 
#if __cpp_impl_coroutine
auto switch_to_new_thread(jthread& out)
{
    struct awaitable {
        jthread* p_out;
        bool await_ready() { return false; }
        void await_suspend(coroutine_handle<> h) {
            jthread& out = *p_out;
            if (out.joinable())
                throw runtime_error("Output jthread parameter not empty");
            out = jthread([h] { h.resume(); });
        }
        void await_resume() {}
    };
    return awaitable{&out};
}
 
struct task {
    struct promise_type {
        struct task get_return_object() { return {}; }
        suspend_never initial_suspend() { return {}; }
        suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};
 
struct task resuming_on_new_thread(jthread& out)
{
    auto starting_tid = this_thread::get_id();
    // suspends coroutine
    co_await switch_to_new_thread(out); 
    // awaiter is destroyed here
    assert(this_thread::get_id() != starting_tid);
}
 
void coroutine_demo()
{
    jthread out;
    resuming_on_new_thread(out);
}
#else
void coroutine_demo() {}
#pragma message("undefined __cpp_impl_coroutine")
#endif
 
#if __cpp_lib_ranges
 
#include <ranges>
 
 
void sort_20()
{
    vector<int> v = {5, 7, 4, 2, 8, 6, 1, 9, 1, 3};
    ranges::sort(v);
    assert(v.front() <= v.back());
    assert(ranges::distance(v));
    assert(!ranges::distance(v.begin(), v.begin()));
}
 
void ranges_20()
{
    auto data = {0, 1, 2, 3};
#if __clang_major__ != 10
    ranges::reverse_view rv {data};
    auto r = data | views::reverse;
    // r is kind of transform_view
    vector result(r.begin(), r.end());
    assert(vector(rv.begin(), rv.end()) == result);
    assert((result == vector{3, 2, 1, 0}));
#endif
    auto [min, max] = ranges::minmax({3, 2, 1});
    auto a = ranges::minmax({3, 2, 1});
    assert(min == 1);
    assert(max == 3);
    assert(!in_range<std::size_t>(-1));
}
 
#else
#pragma message("undefined __cpp_lib_ranges")
#endif
 
#include <experimental/source_location>
 
 
void location_20()
{
    auto l = experimental::source_location::current();
    basic_stringstream<char> buff;
    buff << l.file_name() << ":" << l.line() << ":" << l.column() << l.function_name();
    assert(buff.str().length());
}
 
void functional_20()
{
    auto constexpr plus_one = std::bind_front(std::plus<int>(), 1);
    static_assert(plus_one(2) == 3);
}
 
 
int main()
{
    init_20();
    types_20();
    dynamic_memory_20();
    lambda_20();
#if __cpp_lib_jthread
    jthread t([]{ });
#endif
    coroutine_demo();
    sort_20();
    ranges_20();
    location_20();
    functional_20();
}