قابلیت‌های سی پلاس پلاس (++C) که باید بدانید — با مثال و به زبان ساده

1template<typename T> /*...*/
2requires (T x) // optional set of fictional parameter(s)
3{
4    // simple requirement: expression must be valid
5    x++;    // expression must be valid
6    
7    // type requirement: `typename T`, T type must be a valid type
8    typename T::value_type;
9    typename S<T>;
10
11    // compound requirement: {expression}[noexcept][-> Concept];
12    // {expression} -> Concept<A1, A2, ...> is equivalent to
13    // requires Concept<decltype((expression)), A1, A2, ...>
14    {*x};  // dereference must be valid
15    {*x} noexcept;  // dereference must be noexcept
16    // dereference must  return T::value_type
17    {*x} noexcept -> std::same_as<typename T::value_type>;
18    
19    // nested requirement: requires ConceptName<...>;
20    requires Addable<T>; // constraint Addable<T> must be satisfied
21};

1template<typename T>
2concept Addable = requires(T a, T b)
3{
4    a + b;
5};
6
7template<typename T>
8concept Dividable = requires(T a, T b)
9{
10    a/b;
11};
12
13template<typename T>
14concept DivAddable = Addable<T> && Dividable<T>;
15
16template<typename T>
17void f(T x)
18{
19    if constexpr(Addable<T>){ /*...*/ }
20    else if constexpr(requires(T a, T b) { a + b; }){ /*...*/ }
21}

1template<typename T>
2requires Addable<T>
3auto f1(T a, T b) requires Subtractable<T>; // Addable<T> && Subtractable<T>
4
5auto l = []<typename T> requires Addable<T>
6    (T a, T b) requires Subtractable<T>{};
7
8template<typename T>
9requires Addable<T>
10class C;
11
12// infamous `requires requires`. First `requires` is requires-clause,
13// second one is requires-expression. Useful if you don't want to introduce new
14// concept.
15template<typename T>
16requires requires(T a, T b) {a + b;}
17auto f4(T x);

1template<Addable T>
2void f();

1template<typename T>
2concept Integral = std::integral<T>;
3
4template<typename T>
5concept Integral4 = std::integral<T> && sizeof(T) == 4;
6
7// requires-clause also works here
8template<template<typename T1> requires Integral<T1> typename T>
9void f2(){}
10
11// f() and f2() forms are equal
12template<template<Integral T1> typename T>
13void f(){
14    f2<T>();
15}
16
17// unconstrained template template parameter can accept constrained arguments
18template<template<typename T1> typename T>
19void f3(){}
20
21template<typename T>
22struct S1{};
23
24template<Integral T>
25struct S2{};
26
27template<Integral4 T>
28struct S3{};
29
30void test(){
31    f<S1>();    // OK
32    f<S2>();    // OK
33    // error, S3 is constrained by Integral4 which is more constrained than
34    // f()'s Integral
35    f<S3>();
36
37    // all are OK
38    f3<S1>();
39    f3<S2>();
40    f3<S3>();
41}

1template<typename T>
2struct X{
3    void f() requires std::integral<T>
4    {}
5};
6
7void f(){
8    X<double> x;
9    x.f();  // error
10    auto pf = &X<double>::f;    // error
11}

1template<typename T>
2concept is_sortable = true;
3
4auto l = [](auto x){};
5void f1(auto x){}               // unconstrained template
6void f2(is_sortable auto x){}   // constrained template
7
8template<is_sortable auto NonTypeParameter, is_sortable TypeParameter>
9is_sortable auto f3(is_sortable auto x, auto y)
10{
11    // notice that nothing is allowed between constraint name and `auto`
12    is_sortable auto z = 0;
13    return 0;
14}
15
16template<is_sortable auto... NonTypePack, is_sortable... TypePack>
17void f4(TypePack... args){}
18
19int f();
20
21// takes two parameters
22template<typename T1, typename T2>
23concept C = true;
24// binds second parameter
25C<double> auto v = f(); // means C<int, double>
26
27struct X{
28    operator is_sortable auto() {
29        return 0;
30    }
31};
32
33auto f5() -> is_sortable decltype(auto){
34    f4<1,2,3>(1,2,3);
35    return new is_sortable auto(1);
36}

1template<typename T>
2concept integral_or_floating = std::integral<T> || std::floating_point<T>;
3
4template<typename T>
5concept integral_and_char = std::integral<T> && std::same_as<T, char>;
6
7void f(std::integral auto){}        // #1
8void f(integral_or_floating auto){} // #2
9void f(std::same_as<char> auto){}   // #3
10
11// calls #1 because std::integral is more constrained
12// than integral_or_floating(#2)
13f(int{});
14// calls #2 because it's the only one whose constraint is satisfied
15f(double{});
16// error, #1, #2 and #3's constraints are satisfied but unordered
17// because std::same_as<char> appears only in #3
18f(char{});
19
20void f(integral_and_char auto){}    // #4
21
22// calls #4 because integral_and_char is more
23// constrained than std::same_as<char>(#3) and std::integral(#1)
24f(char{});

1template<typename T>
2requires std::is_integral_v<T>  // uses type traits instead of concepts
3void f1(){}  // #1
4
5template<typename T>
6requires std::is_integral_v<T> || std::is_floating_point_v<T>
7void f1(){}  // #2
8
9// error, #1 and #2 have common `std::is_integral_v<T>` expression
10// but at different locations(line 2 vs. line 6), thus, #1 and #2 constraints
11// are unordered and the call is ambiguous
12f1(int{});
13
14template<typename T>
15concept C1 = requires{      // requires-expression is not decomposed
16    requires std::integral<T>;
17};
18
19template<typename T>
20concept C2 = requires{      // requires-expression is not decomposed
21    requires (std::integral<T> || std::floating_point<T>);
22};
23
24void f2(C1 auto){}  // #3
25void f2(C2 auto){}  // #4
26
27// error, since requires-expressions are not decomposed, #3 and #4 have
28// completely unrelated and hence unordered constraints and the call is
29// ambiguous
30f2(int{});

1template<typename T>
2class optional{
3public:
4    optional() = default;
5
6    // trivial copy-constructor
7    optional(const optional&) = default;
8
9    // non-trivial copy-constructor
10    optional(const optional& rhs)
11        requires(!std::is_trivially_copy_constructible_v<T>){
12        // ...
13    }
14
15    // trivial destructor
16    ~optional() = default;
17
18    // non-trivial destructor
19    ~optional() requires(!std::is_trivial_v<T>){
20        // ...
21    }
22    // ...
23private:
24    T value;
25};
26
27static_assert(std::is_trivial_v<optional<int>>);
28static_assert(!std::is_trivial_v<optional<std::string>>);

1// module.cpp
2// dots in module name are for readability purpose, they have no special meaning
3export module my.tool;  // module declaration
4
5export void f(){}       // export f()
6void g(){}              // but not g()
7
8// client.cpp
9import my.tool;
10
11f();    // OK
12g();    // error, not exported

1// tool.cpp
2export module tool; // primary module interface unit
3export import :helpers; // re-export(see below) helpers partition
4
5export void f();
6export void g();
7
8// tool.internals.cpp
9module tool:internals;  // implementation partition
10void utility();
11
12// tool.impl.cpp
13module tool;    // implementation unit, implicitly imports primary module unit
14import :internals;
15
16void utility(){}
17
18void f(){
19    utility();
20}
21
22// tool.impl2.cpp
23module tool;    // another implementation unit
24void g(){}
25
26// tool.helpers.cpp
27export module tool:helpers; // module interface partition
28import :internals;
29
30export void h(){
31    utility();
32}
33
34// client.cpp
35import tool;
36
37f();
38g();
39h();

1// tool.cpp
2module tool;
3export import :helpers; // import and re-export helpers interface partition
4
5export int x{}; // export single declaration
6
7export{         // export multiple declarations
8    int y{};
9    void f(){};
10}
11
12export namespace A{ // export the whole namespace
13    void f();
14    void g();
15}
16
17namespace B{
18    export void f();// export a single declaration within a namespace
19    void g();
20}
21
22namespace{
23    export int x;   // error, x has internal linkage
24    export void f();// error, f() has internal linkage
25}
26
27export class C; // export as incomplete type
28class C{};
29export C get_c();
30
31// client.cpp
32import tool;
33
34C c1;    // error, C is incomplete
35auto c2 = get_c();  // OK

1// tool.cpp
2export module tool;
3import :helpers;  // import helpers partition
4
5export void f(){}
6
7// tool.helpers.cpp
8export module tool:helpers;
9
10export void g(){}
11
12// client.cpp
13import tool;
14
15f();
16g();

1// header.h
2#pragma once
3class A{};
4void g(){}
5
6// tool.cpp
7module;             // global module fragment
8#include "header.h"
9export module tool; // ends here
10
11export void f(){    // uses declarations from header.h
12    g();
13    A a;
14}

1export module tool; // interface
2
3export void f();    // declared here
4
5module :private;    // implementation details
6
7void f(){}          // defined here

1// header.h
2struct C{
3    void f(){}  // still inline because attached to a global module
4};
5
6// tool.cpp
7module;
8#include "header.h"
9
10export module tool;
11
12class A{};  // not exported
13
14export struct B{// B is attached to module "tool"
15    void f(){   // not implicitly inline anymore
16        A a;    // can safely use non-exported name
17    }
18
19    inline void g(){
20        A a;    // oops, uses non-exported name
21    }
22
23    inline void h(){
24        f();    // fine, f() is not inline
25    }
26};
27
28// client.cpp
29import tool;
30
31B b;
32b.f();  // OK
33b.g();  // error, A is undefined
34b.h();  // OK

1cppcoro::task<int> someAsyncTask()
2{
3    int result;
4    // get the result somehow
5    co_return result;
6}
7
8// task<> is analog of void for normal function
9cppcoro::task<> usageExample()
10{
11    // creates a new task but doesn't start executing the coroutine yet
12    cppcoro::task<int> myTask = someAsyncTask();
13    // ...
14    // Coroutine is only started when we later co_await the task.
15    auto result = co_await myTask;
16}
17
18// will lazily generate numbers from 0 to 9
19cppcoro::generator<std::size_t> getTenNumbers()
20{
21    std::size_t n{0};
22    while (n != 10)
23    {
24        co_yield n++;
25    }
26}
27
28void printNumbers()
29{
30    for(const auto n : getTenNumbers())
31    {
32        std::cout << n;    
33    }
34}

1template<typename T1, typename T2>
2void TestComparisons(T1 a, T2 b)
3{
4    (a < b), (a <= b), (a > b), (a >= b), (a == b), (a != b);
5}
6
7struct S2
8{
9    int a;
10    int b;
11};
12
13struct S1
14{
15    int x;
16    int y;
17    // support homogeneous comparisons
18    auto operator<=>(const S1&) const = default;
19    // this is required because there's operator==(const S2&) which prevents
20    // implicit declaration of defaulted operator==()
21    bool operator==(const S1&) const = default;
22
23    // support heterogeneous comparisons
24    std::strong_ordering operator<=>(const S2& other) const
25    {
26        if (auto cmp = x <=> other.a; cmp != 0)
27            return cmp;
28        return y <=> other.b;
29    }
30
31    bool operator==(const S2& other) const
32    {
33        return (*this <=> other) == 0;
34    }
35};
36
37TestComparisons(S1{}, S1{});
38TestComparisons(S1{}, S2{});
39TestComparisons(S2{}, S1{});

1template<typename T>
2struct X
3{
4    friend constexpr std::partial_ordering operator<=>(X, X) requires(sizeof(T) != 1) = default;
5    // implicitly declares:
6    // friend constexpr bool operator==(X, X) requires(sizeof(T) != 1) = default;
7
8    [[nodiscard]] virtual std::strong_ordering operator<=>(const X&) const = default;
9    // implicitly declares:
10    //[[nodiscard]] virtual bool operator==(const X&) const = default; 
11};

1struct S3{
2    int x;      // int-s are strongly ordered
3    double d;   // but double-s are partially ordered
4    // thus, the resulting category is std::partial_ordering
5    auto operator<=>(const S3&) const = default;
6};
7static_assert(std::is_same_v<decltype(S3{} <=> S3{}), std::partial_ordering>);

1struct S4
2{
3    int x;
4    int y;
5    // member version must have op(const T&) const; form
6    auto operator<=>(const S3&) const = default;
7
8    // friend version can take arguments by const-reference or by-value
9    // friend auto operator<=>(const S3&, const S3&) = default;
10    // friend auto operator<=>(S3, S3) = default;
11};

1struct S5
2{
3    int x;
4    std::strong_ordering operator<=>(const S5&) const;
5    bool operator==(const S5&) const;
6};
7
8std::strong_ordering S5::operator<=>(const S5&) const = default;
9bool S5::operator==(const S5&) const = default;

1// not in our immediate control
2struct Legacy
3{
4    bool operator==(Legacy const&) const;
5    bool operator<(Legacy const&) const;
6};
7
8struct S6
9{
10    int x;
11    Legacy l;
12    // deleted because Legacy doesn't have operator<=>(), comparison category
13    // can't be deduced
14    auto operator<=>(const S6&) const = default;
15};
16
17struct S7
18{
19    int x;
20    Legacy l;
21
22    std::strong_ordering operator<=>(const S7& rhs) const = default;
23    /*
24    Since comparison category is provided explicitly, ordering can be
25    synthesized using operator<() and operator==(). They must return exactly
26    `bool` for this to work. It will work for weak and partial ordering as well.
27    
28    Here's an example of synthesized operator<=>():
29    std::strong_ordering operator<=>(const S7& rhs) const
30    {
31        // use operator<=>() for int
32        if(auto cmp = x <=> rhs.x; cmp != 0) return cmp;
33
34        // synthesize ordering for Legacy using operator<() and operator==()
35        if(l == rhs.l) return std::strong_ordering::equal;
36        if(l < rhs.l) return std::strong_ordering::less;
37        return std::strong_ordering::greater;
38    }
39    */
40};
41
42struct NoEqual
43{
44    bool operator<(const NoEqual&) const = default;
45};
46
47struct S8
48{
49    NoEqual n;
50    // deleted, NoEqual doesn't have operator<=>()
51    // auto operator<=>(const S8&) const = default;
52
53    // deleted as well because NoEqual doesn't have operator==()
54    std::strong_ordering operator<=>(const S8&) const = default;
55};
56
57struct W
58{
59    std::weak_ordering operator<=>(const W&) const = default;
60};
61
62struct S9
63{
64    W w;
65    // ask for strong_ordering but W can provide only weak_ordering, this will
66    // yield an error during instantiation
67    std::strong_ordering operator<=>(const S9&) const = default;
68    void f()
69    {
70        (S9{} <=> S9{});    // error
71    }
72};

1struct S4
2{
3    int& r;
4    // deleted because of reference member
5    auto operator<=>(const S4&) const = default;
6};

1struct S{
2    void f(){
3        [=]{};          // captures this by reference, deprecated since C++20
4        [=, *this]{};   // OK since C++17, captures this by value
5        [=, this]{};    // OK since C++20, captures this by reference
6    }
7};

1// lambda that expect std::vector<T>
2// until C++20:
3[](auto vector){
4    using T =typename decltype(vector)::value_type;
5    // use T
6};
7// since C++20:
8[]<typename T>(std::vector<T> vector){
9    // use T
10};
11
12// access argument type
13// until C++20
14[](const auto& x){
15    using T = std::decay_t<decltype(x)>;
16    // using T = decltype(x); // without decay_t<> it would be const T&, so
17    T copy = x;               // copy would be a reference type
18    T::static_function();     // and these wouldn't work at all
19    using Iterator = typename T::iterator;
20};
21// since C++20
22[]<typename T>(const T& x){
23    T copy = x;
24    T::static_function();
25    using Iterator = typename T::iterator;
26};
27
28// perfect forwarding
29// until C++20:
30[](auto&&... args){
31    return f(std::forward<decltype(args)>(args)...);
32};
33// since C++20:
34[]<typename... Ts>(Ts&&... args){
35    return f(std::forward<Ts>(args)...);
36};
37
38// and of course you can mix them with auto-parameters
39[]<typename T>(const T& a, auto b){};

1using L = decltype([]{});   // lambdas have no linkage
2L PublicApi();              // L can't be used for external linkage
3
4// in template , two different declarations
5template<class T> void f(decltype([]{}) (*s)[sizeof(T)]);
6template<class T> void f(decltype([]{}) (*s)[sizeof(T)]);
7
8// again, lambda types are never equivalent
9static decltype([]{}) f();
10static decltype([]{}) f(); // error, return type mismatch
11
12static decltype([]{}) g();
13static decltype(g()) g(); // okay, redeclaration
14
15// each specialization has its own lambda with unique type
16template<typename T>
17using R = decltype([]{});
18
19static_assert(!std::is_same_v<R<int>, R<char>>);
20
21// Lambda-based SFINAE and constraints are not supported, it just fails
22template <class T>
23auto f(T) -> decltype([]() { T::invalid; } ());
24void f(...);
25
26template<typename T>
27void g(T) requires requires{
28    [](){typename T::invalid x;}; }
29{}
30void g(...){}
31
32f(0);  // error
33g(0);  // error

1// a.h
2template<typename T>
3int counter(){
4    static int value{};
5    return value++;
6}
7
8inline int f(){
9    return counter<decltype([]{})>();
10}
11
12template<auto> struct S{ void call(){} };
13// cast lambda to pointer
14inline S<+[]{}> g_s;
15
16// a.cpp
17#include "a.h"
18auto v = f();
19g_s.call();
20
21// b.cpp
22#include "a.h"
23auto v = f();
24g_s.call();

1auto greater = [](auto x,auto y)
2{
3    return x > y;
4};
5// requires default constructible type
6std::map<std::string, int, decltype(greater)> map;
7auto map2 = map;    // requires default assignable type

1void g(int, int){}
2
3// C++17
4template<class F, class... Args>
5auto delay_apply(F&& f, Args&&... args) {
6    return [f=std::forward<F>(f), tup=std::make_tuple(std::forward<Args>(args)...)]()
7            -> decltype(auto) {
8        return std::apply(f, tup);
9    };
10}
11
12// C++20
13template<typename F, typename... Args>
14auto delay_call(F&& f, Args&&... args) {
15    return [f = std::forward<F>(f), ...f_args=std::forward<Args>(args)]()
16            -> decltype(auto) {
17        return f(f_args...);
18    };
19}
20
21void f(){
22    delay_call(g, 1, 2)();
23}

1consteval int GetInt(int x){
2    return x;
3}
4
5constexpr void f(){
6    auto x1 = GetInt(1);
7    constexpr auto x2 = GetInt(x1); // error x1 is not a constant-expression
8}

1struct Base{
2    constexpr virtual ~Base() = default;
3    virtual int Get() const = 0;    // non-constexpr
4};
5
6struct Derived1 : Base{
7    constexpr int Get() const override {
8        return 1;
9    }
10};
11
12struct Derived2 : Base{
13    constexpr int Get() const override {
14        return 2;
15    }
16};
17
18constexpr auto GetSum(){
19    const Derived1 d1;
20    const Derived2 d2;
21    const Base* pb1 = &d1;
22    const Base* pb2 = &d2;
23
24    return pb1->Get() + pb2->Get();
25}
26
27static_assert(GetSum() == 1 + 2);   // evaluated at compile-time

1constexpr void f(){
2    try{
3        auto p = new int;
4        // ...
5        delete p;
6    }
7    catch(...){     // ignored at compile-time
8        // ...
9    }
10}

1struct Base1{
2    virtual ~Base1() = default;
3    constexpr virtual int get() const = 0;
4};
5
6struct Derived1 : Base1{
7    constexpr int get() const override {
8        return 1;
9    }
10};
11
12struct Base2{
13    virtual ~Base2() = default;
14    constexpr virtual int get() const = 0;
15};
16
17struct Derived2 : Base2{
18    constexpr int get() const override {
19        return 2;
20    }
21};
22
23template<typename Base, typename Derived>
24constexpr auto downcasted_get(){
25    const Derived d;
26    const Base& upcasted = d;
27    const auto& downcasted = dynamic_cast<const Derived&>(upcasted);
28
29    return downcasted.get();
30}
31
32static_assert(downcasted_get<Base1, Derived1>() == 1);
33static_assert(downcasted_get<Base2, Derived2>() == 2);
34
35// compile-time error, cannot cast Derived1 to Base2
36static_assert(downcasted_get<Base2, Derived1>() == 1);

1union Foo {
2  int i;
3  float f;
4};
5
6constexpr int f() {
7  Foo foo{};
8  foo.i = 3;    // i is an active member
9  foo.f = 1.2f; // valid since C++20, f becomes an active member
10
11//   return foo.i;  // error, reading inactive union member
12  return foo.f;
13}

1constexpr auto get_str()
2{
3    std::string s1{"hello "};
4    std::string s2{"world"};
5    std::string s3 = s1 + s2;
6    return s3;
7}
8
9constexpr auto get_array()
10{
11    constexpr auto N = get_str().size();
12    std::array<char, N> arr{};
13    std::copy_n(get_str().data(), N, std::begin(arr));
14    return arr;
15}
16
17static_assert(!get_str().empty());
18
19// error because it holds data allocated at compile-time
20constexpr auto str = get_str();
21
22// OK, string is stored in std::array<char>
23constexpr auto result = get_array();

1struct NonTrivial{
2    bool b = false;
3};
4
5struct Trivial{
6    bool b;
7};
8
9template <typename T>
10constexpr T f1(const T& other) {
11    T t;        // default initialization
12    t = other;
13    return t;
14}
15
16template <typename T>
17constexpr auto f2(const T& other) {
18    T t;
19    return t.b;
20}
21
22void test(){
23    constexpr auto a = f1(Trivial{});   // error in C++17, OK in C++20
24    constexpr auto b = f1(NonTrivial{});// OK
25
26    constexpr auto c = f2(Trivial{}); // error, uninitialized Trivial::b is used
27    constexpr auto d = f2(NonTrivial{}); // OK
28}

1constexpr int add(int a, int b){
2    if (std::is_constant_evaluated()){
3        return a + b;
4    }
5    else{
6        asm("asm magic here");
7        //...
8    }
9}

1constexpr int GetNumber(){
2    if(std::is_constant_evaluated()){   // should not be `if constexpr`
3        return 1;
4    }
5    return 2;
6}
7
8constexpr int GetNumber(int x){
9    if(std::is_constant_evaluated()){   // should not be `if constexpr`
10        return x;
11    }
12    return x+1;
13}
14
15void f(){
16    constexpr auto v1 = GetNumber();
17    const auto v2 = GetNumber();
18
19    // initialization of a non-const variable, not constant-evaluated
20    auto v3 = GetNumber();
21
22    assert(v1 == 1);
23    assert(v2 == 1);
24    assert(v3 == 2);
25
26    constexpr auto v4 = GetNumber(1);
27    int x = 1;
28
29    // x is not a constant-expression, not constant-evaluated
30    const auto v5 = GetNumber(x);
31
32    assert(v4 == 1);
33    assert(v5 == 2);    
34}
35
36// pathological examples
37// always returns `true`
38constexpr bool IsInConstexpr(int){
39    if constexpr(std::is_constant_evaluated()){ // always `true`
40        return true;
41    }
42    return false;
43}
44
45// always returns `sizeof(int)`
46constexpr std::size_t GetArraySize(int){
47    int arr[std::is_constant_evaluated()];  // always int arr[1];
48    return sizeof(arr);
49}
50
51// always returns `1`
52constexpr std::size_t GetStdArraySize(int){
53    std::array<int, std::is_constant_evaluated()> arr;  // std::array<int, 1>
54    return arr.size();
55}

1// none of the types below are an aggregate in C++20
2struct S{
3    int x{2};
4    S(int) = delete; // user-declared ctor
5};
6
7struct X{
8    int x;
9    X() = default;  // user-declared ctor
10};
11
12struct Y{
13    int x;
14    Y();            // user-provided ctor
15};
16
17Y::Y() = default;
18
19void f(){
20    S s(1);     // always an error
21    S s2{1};    // OK in C++17, error in C++20, S is not an aggregate now
22    X x{1};     // OK in C++17, error in C++20
23    Y y{2};     // always an error
24}

1template<typename T, typename U>
2struct S{
3    T t;
4    U u;
5};
6// deduction guide was needed in C++17
7// template<typename T, typename U>
8// S(T, U) -> S<T,U>;
9
10S s{1, 2.0};    // S<int, double>

1template<typename T>
2struct MyData{
3    T data;
4};
5MyData(const char*) -> MyData<std::string>;
6
7MyData s1{"abc"};   // OK, MyData<std::string> using deduction guide
8MyData<int> s2{1};  // OK, explicit template argument
9MyData s3{1};       // Error, CTAD isn't involved

1template<typename T, std::size_t N>
2struct Array{
3    T data[N];
4};
5
6Array a{{1, 2, 3}}; // Array<int, 3>, notice additional braces
7Array str{"hello"}; // Array<char, 6>

1template<typename T, typename U>
2struct Pair{
3    T first;
4    U second;
5};
6
7template<typename T, std::size_t N>
8struct A1{
9    T data[N];
10    T oneMore;
11    Pair<T, T> p;
12};
13
14template<typename T>
15struct A2{
16    T data[3];
17    T oneMore;
18    Pair<int, int> p;
19};
20
21// A1::data is an array of dependent bound and A1::p is a dependent type, thus,
22// no brace elision for them
23A1 a1{{1,2,3}, 4, {5, 6}};  // A1<int, 3>
24// A2::data is an array of non-dependent bound and A1::p is a non-dependent type,
25// thus, brace elision works
26A2 a2{1, 2, 3, 4, 5, 6};    // A2<int>

1template<typename... Ts>
2struct Overload : Ts...{
3    using Ts::operator()...;
4};
5// no need for deduction guide anymore
6
7Overload p{[](int){
8        std::cout << "called with int";
9    }, [](char){
10        std::cout << "called with char";
11    }
12};     // Overload<lambda(int), lambda(char)>
13p(1);   // called with int
14p('c'); // called with char

1template<typename T, typename...Ts>
2struct Pack : Ts... {
3    T x;
4};
5
6// can deduce only the first element
7Pack p1{1};         // Pack<int>
8Pack p2{[]{}};      // Pack<lambda()>
9Pack p3{1, []{}};   // error

1struct A{};
2struct B{};
3struct C{};
4struct D{
5    operator C(){return C{};}
6};
7
8template<typename...Ts>
9struct P : std::tuple<Ts...>, Ts...{
10};
11
12P{std::tuple<A, B, C>{}, A{}, B{}, C{}}; // P<A, B, C>
13
14// equivalent to the above, since pack elements were deduced for
15// std::tuple<A, B, C> there's no need to repeat their types
16P{std::tuple<A, B, C>{}, {}, {}, {}}; // P<A, B, C>
17
18// since we know the whole P<A, B, C> type after std::tuple initializer, we can
19// omit trailing initializers, elements will be value-initialized as usual
20P{std::tuple<A, B, C>{}, {}, {}}; // P<A, B, C>
21
22// error, pack deduced from first initializer is <A, B, C> but got <A, B, D> for
23// the trailing pack, implicit conversions are not considered
24P{std::tuple<A, B, C>{}, {}, {}, D{}};