类模板实参推导（CTAD）(C++17 起)

std::pair p(2, 4.5);     // 推导出 std::pair<int, double> p(2, 4.5);
std::tuple t(4, 3, 2.5); // 同 auto t = std::make_tuple(4, 3, 2.5);
std::less l;             // 同 std::less<void> l;

template<class T>
struct A
{
    A(T, T);
};

auto y = new A{1, 2}; // 分配的类型是 A<int>

auto lck = std::lock_guard(mtx);     // 推导出 std::lock_guard<std::mutex>
std::copy_n(vi1, 3,
    std::back_insert_iterator(vi2)); // 推导出 std::back_insert_iterator<T>，
                                     // 其中 T 是容器 vi2 的类型
std::for_each(vi.begin(), vi.end(),
    Foo([&](int i) {...}));          // 推导出 Foo<T>，其中 T 是独有的 lambda 类型

template<class T>
struct UniquePtr
{
    UniquePtr(T* t);
};

UniquePtr dp{new auto(2.0)};

// 一个声明的构造函数：
// C1：UniquePtr(T*);

// 隐式生成的推导指引集：

// F1：template<class T>
//     UniquePtr<T> F(T *p);

// F2：template<class T>
//     UniquePtr<T> F(UniquePtr<T>); // 复制推导候选

// 要初始化的假想类：
// struct X
// {
//     template<class T>
//     X(T *p);         // 从 F1
//     
//     template<class T>
//     X(UniquePtr<T>); // 从 F2
// };

// X 对象的以“new double(2.0)”为初始化式的直接初始化
// 会选择与 T = double 对应的指引 F1 的构造函数
// 对于 T=double 的 F1，返回类型是 UniquePtr<double>

// 结果：
// UniquePtr<double> dp{new auto(2.0)}

template<class T>
struct S
{
    template<class U>
    struct N
    {
        N(T);
        N(T, U);
        
        template<class V>
        N(V, U);
    };
};
 
S<int>::N x{2.0, 1};

// 隐式生成的推导指引是（注意已知 T 是 int）

// F1：template<class U>
//     S<int>::N<U> F(int);

// F2：template<class U>
//     S<int>::N<U> F(int, U);

// F3：template<class U, class V>
//     S<int>::N<U> F(V, U);

// F4：template<class U>
//     S<int>::N<U> F(S<int>::N<U>);（复制推导候选）

// 以“{2.0, 1}”为初始化式的直接列表初始化的重载决议
// 选择 U=int 与 V=double 的 F3。
// 返回类型是 S<int>::N<int>

// 结果：
// S<int>::N<int> x{2.0, 1};

// 模板的声明
template<class T>
struct container
{
    container(T t) {}
    
    template<class Iter>
    container(Iter beg, Iter end);
};

// 额外的推导指引
template<class Iter>
container(Iter b, Iter e) -> container<typename std::iterator_traits<Iter>::value_type>;

// 使用
container c(7); // OK：用隐式生成的指引推导出 T=int
std::vector<double> v = {/* ... */};
auto d = container(v.begin(), v.end()); // OK：推导出 T=double
container e{5, 6}; // 错误：std::iterator_traits<int>::value_type 不存在

template<class T>
struct A
{
    explicit A(const T&, ...) noexcept; // #1
    A(T&&, ...);                        // #2
};

int i;
A a1 = {i, i}; // 错误：不能从 #2 的右值引用推导
               // 且 #1 是 explicit 的，所以复制初始化中不予考虑。
A a2{i, i};    // OK，#1 推导出 A<int> 并且初始化
A a3{0, i};    // OK，#2 推导出 A<int> 并且初始化
A a4 = {0, i}; // OK，#2 推导出 A<int> 并且初始化

template<class T>
A(const T&, const T&) -> A<T&>; // #3

template<class T>
explicit A(T&&, T&&)  -> A<T>;  // #4

A a5 = {0, 1}; // 错误：#3 推导出 A<int&> 且 #1 和 #2 会生成形参相同的构造函数。
A a6{0, 1};    // OK，#4 推导出 A<int> 并以 #2 初始化
A a7 = {0, i}; // 错误：#3 推导出 A<int&>
A a8{0, i};    // 错误：#3 推导出 A<int&>

// 注：请查看 https://github.com/cplusplus/CWG/issues/647，
// 称示例 a7 与 a8 不正确，可替换为
//A a7 = {0, i}; // 错误：#2 与 #3 都匹配，重载解析失败
//A a8{i,i};     // 错误：#3 推导出 A<int&>，#1 和 #2 声明同一个构造函数

template<class T>
struct B
{
    template<class U>
    using TA = T;
    
    template<class U>
    B(U, TA<U>); // #1
};

// 从 #1 产生的隐式推导指引等价于
//   template<class T, class U>
//   B(U, T) -> B<T>;
// 而不是
//   template<class T, class U>
//   B(U, typename B<T>::template TA<U>) -> B<T>;
// 后者无法被推导

B b{(int*)0, (char*)0}; // OK，推导出 B<char*>

std::tuple t1(1, 2, 3);                // OK：推导
std::tuple<int, int, int> t2(1, 2, 3); // OK：提供了所有实参

std::tuple<> t3(1, 2, 3);    // 错误：tuple<> 中没有匹配的构造函数。不进行推导。
std::tuple<int> t4(1, 2, 3); // 错误

template<class T>
struct S
{
    S(T);
};
S(char const*) -> S<std::string>;
S s{"hello"}; // 推导出 S<std::string>

template<class T>
struct X
{
    X(T) {}
    
    template<class Iter>
    X(Iter b, Iter e) {}
 
    template<class Iter>
    auto foo(Iter b, Iter e)
    {
        return X(b, e); // 不推导：X 是当前的 X<T>
    }
 
    template<class Iter>
    auto bar(Iter b, Iter e)
    {
        return X<typename Iter::value_type>(b, e); 必须指定所需的模板实参
    }
 
    auto baz()
    {
        return ::X(0); // 不是注入类名；推导为 X<int>
    }
};

template<class T>
struct A
{
    A(T, int*);     // #1
    A(A<T>&, int*); // #2
    
    enum { value };
};

template<class T, int N = T::value>
A(T&&, int*) -> A<T>; // #3

A a{1, 0}; // 使用 #1 推导出 A<int> 并以 #1 初始化
A b{a, 0}; // 使用 #2（比 #3 更特殊）推导出 A<int> 并以 #2 初始化

template<class T>
struct A
{
    using value_type = T;
    
    A(value_type); // #1
    A(const A&);   // #2
    A(T, T, int);  // #3
    
    template<class U> 
    A(int, T, U);  // #4
};                 // #5，复制推导候选 A(A);

A x(1, 2, 3); // 使用 #3，从非模板构造函数生成

template<class T>
A(T) -> A<T>; // #6，比 #5 更不特殊

A a(42); // 使用 #6 推导出 A<int> 并以 #1 初始化
A b = a; // 使用 #5 推导出 A<int> 并以 #2 初始化

template<class T>
A(A<T>) -> A<A<T>>;  // #7，与 #5 一样特殊

A b2 = a; // 使用 #7 推导出 A<A<int>> 并以 #1 初始化

template<class T>
struct A
{
    template<class U>
    A(T&&, U&&, int*); // #1：T&& 不是转发引用
                       //     U&& 是转发引用
    
    A(T&&, int*);      // #2：T&& 不是转发引用
};

template<class T>
A(T&&, int*) -> A<T>; // #3：T&& 是转发引用

int i, *ip;
A a{i, 0, ip};  // 错误，不能从 #1 推导
A a0{0, 0, ip}; // 使用 #1 推导出 A<int> 并以 #1 初始化
A a2{i, ip};    // 使用 #3 推导出 A<int&> 并以 #2 初始化

std::tuple t1{1};  //std::tuple<int>
std::tuple t2{t1}; //std::tuple<int>，不是 std::tuple<std::tuple<int>>

std::vector v1{1, 2};   // std::vector<int>
std::vector v2{v1};     // std::vector<int>，不是 std::vector<std::vector<int>>（P0702R1）
std::vector v3{v1, v2}; // std::vector<std::vector<int>>

std::vector v1{1, 2}; // std::vector<int>

std::vector v2(v1.begin(), v1.end()); // std::vector<int>
std::vector v3{v1.begin(), v1.end()}; // std::vector<std::vector<int>::iterator>

std::tuple p1{1, 1.0};             // std::tuple<int, double>，使用推导
auto p2 = std::make_tuple(1, 1.0); // std::tuple<int, double>，C++17 前