TOP 5 most astounding C++20 Syntax

[](){}();

// first create std::function without a default.
std::function<void()> f_null;

// f_null contains a nullptr now!
if( f_null ) { // calls operator bool()
    f_null(); // without the if check this would throw!
}


// now create a std::function with a no-op default.
std::function<void()> f_default( []() {} );
f_default(); // can be called unconditionally! :)

struct Test
{
    // in real world code this would be private ...
    std::function<void()>  mMemFun = [](){};
       
    void Call() const
    {
        mMemFun(); // can call unconditionally.
    }
};

Test test;   // default construct with no-op lambda.
test.Call();
test.mMemFun = []() { puts( "Test from TOP No. 5." ); };
test.Call();

explicit Constructor( X x, Y y, Z z )
try : mMember1( x ) 
    , mMember12( y, z )
{
} catch( ... ) {
}

class Foo
{
    std::string mStr;
public:
    // Constructor
    explicit Foo( std::string const & s, size_t pos )
    // # 4: Function try block. The try block includes the initializer list!
    try : mStr( s, pos ) 
    {
        puts( "Foo constructor - normal block." );
    } catch( ... ) {
        // here can only cleanup already initialized/allocated stuff, which must be clean up manually. 
        // Constructed members are destructed already.
        // the class instance itself stays broken. this catch block will auto re-throw the exception always!
        puts( "Foo constructor - catch block!." );
    }
};

try {
    std::string s = "test";
    Foo foo1( s, 2 );  // not throw
    Foo foo2( s, 10 ); // will throw std::out_of_range
} catch( ... ) {
}

template<typename T>
explicit Constructor( long long x ) noexcept(noexcept(T(x)))
// ...

class Throw
{
    long long z = 23;
public:
    // this constructor might throw
    explicit Throw( long long x )
        : z( x )
    {
        // just pick some condition when throw...
        if( x % 2 ) throw std::runtime_error( "Throw" );
    }
};

class NoThrow
{
    long long a = 42;
public:
    // this constructor is noexcept - never throws
    NoThrow( long long x ) noexcept
        : a(x)
    {
    }
};

template< class T>
class Foo
{
    T mT;
public:
    // # 3: the noexcept( noexcept() ), the inner noexcept is the noexcept operator, the outer is the noexcept specifier.
    explicit Foo( long long x ) noexcept(noexcept(T(x)))
        : mT(x)
    {
        std::cout << "Foo is noexcept " << std::boolalpha << noexcept(Foo( x )) << std::noboolalpha << std::endl;
    }
};


Foo<Throw>    foo1(4LL);     // foo1 may throw....
Foo<NoThrow>  foo2(101LL);   // foo2 never throws.

template<typename T>
T mul( T const & t ) requires requires { t * t; }
{ /* ... */ }

template< class T >
class Bar
{
    T mT;
public:
    Bar( T t )
        : mT(t)
    { }

    // # 2: requires requires, first is the requires constraint, second the ad-hoc requires expression (instead of an already usable concept)
    T mul( T const & t ) requires requires { t * t; }
    {
        // t has the binary operator*()
        return mT * t;
    }
};


Bar bar1( 2 ); // T is int
std::cout << "bar1.mul(3) == " << bar1.mul( 3 ) << std::endl; // compiles, int has * operator
Bar bar2( std::string("test") ); // now T is std::string
// will not compile, std::string has no operator *
// error C7500: 'mul': no function satisfied its constraints
//std::cout << "bar2.mul(test 2) == " << bar2.mul( std::string("test 2") ) << std::endl;

auto res = lambda_value.operator()< int >( 1LL );

// first construct the lambda. (The construct itself could also be judged as No. 1 astounding syntax, couldn't it? ;-) )
auto lambda_value = []<typename RET>( auto n ) noexcept
{
    if( n < std::numeric_limits<RET>::min() ) {
        return std::numeric_limits<RET>::min();
    } else if( n > std::numeric_limits<RET>::max() ) {
        return std::numeric_limits<RET>::max();
    } else {
        return static_cast<RET>(n);
    }
};

// # 1: explicit template specialization of the operator () of a lambda!
auto res = lambda_value.operator()< int >( 1LL ); // param is long long, return type is explicit set to int.
std::cout << "lambda_value.operator()< int >( 1LL ) == " << res << std::endl;
auto res2 = lambda_value.operator()< signed char >( 129LL ); // param is long long, return type is explicit set to signed char.
std::cout << "lambda_value.operator()< signed char >(129LL) == " << static_cast<int>(res2) << std::endl;

{({()}),({()})}