クラステンプレートの実引数推定(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_inserter(vi2)
std::for_each(vi.begin(), vi.end(), Foo([&](int i) {...})); // Foo<T> を推定します。 ただし
                                                            // T は一意なラムダ型です。

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 から
// };
// 「new double(2.0)」を初期化子として用いた、オブジェクト X の直接初期化は、
// 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&> に推定されます。

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 A, class B> struct Agg {A a; B b; };
// デフォルト、コピー、およびムーブコンストラクタから暗黙の推定ガイドが形成されます。
template<class A, class B> Agg(A a, B b) -> Agg<A, B>;
Agg agg{1, 2.0}; // ユーザ定義のガイドから Agg<int, double> に推定されます。
 
template <class... T>
array(T&&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;
auto a = array{1, 2, 5u}; // ユーザ定義のガイドから array<unsigned, 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
}; // A(A); #5 (コピー推定候補)
 
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未満の手法)