テンプレートの実引数推定

template<typename To, typename From> To convert(From f);
 
void g(double d) 
{
    int i = convert<int>(d);    // convert<int, double>(double) を呼びます。
    char c = convert<char>(d);  // convert<char, double>(double) を呼びます。
    int(*ptr)(float) = convert; // convert<int, float>(float) を実体化します。
}

#include <iostream>
 
int main() 
{
    std::cout << "Hello, world" << std::endl;
    // operator<< が名前探索され、 ADL によって std::operator<< が発見され、
    // std::operator<< <char, std::char_traits<char>> に推定されます (2回とも)。
    // std::endl は &std::endl<char, std::char_traits<char>> に推定されます。
}

template<class T> int f(T(*p)(T));
int g(int);
int g(char);
f(g); // P = T(*)(T), A = オーバーロード集合
      // P = T(*)(T), A1 = int(int): T の推定結果 = int
      // P = T(*)(T), A2 = int(char): T の推定に失敗
      // オーバーロードのうちひとつだけが上手くいったので、推定は成功です。

template<int i> class A { };
template<short s> void f(A<s>); // 非型テンプレート仮引数の型は short です。
 
void k1()
{
    A<1> a;  // 非型テンプレート仮引数の型は int です。
    f(a);    // P = A<(short)s>, A = A<(int)1>
             // エラー、推定された非型テンプレート実引数は
             // 対応するテンプレート実引数と同じ型でありません。
    f<1>(a); // OK、テンプレート実引数は推定されず、
             // f<(short)1>(A<(short)1>) を呼びます。
}
 
template<int&> struct X;
template<int& R> void k2(X<R>&);
int n;
void g(X<n> &x) {
    k2(x); // P = X<R>, A = X<n>
           // 仮引数の型は int& です。
           // 実引数の型は構造体 X のテンプレート宣言の int& です。
           // OK (CWG 2091 適用済みの場合)、 R は n への参照に推定されます。
}

template<typename T> void f(T = 5, T = 7);
 
void g()
{
    f(1);     // OK、 f<int>(1, 7) を呼びます。
    f();      // エラー、 T を推定できません。
    f<int>(); // OK、 f<int>(5, 7) を呼びます。
}

template<template<typename> class X> struct A { }; // A はテンプレートテンプレート仮引数を持つテンプレートです。
template<template<typename> class TT> void f(A<TT>) { }
template<class T> struct B { };
A<B> ab;
f(ab); // P = A<TT>, A = A<B>: TT の推定結果 = B。 f(A<B>) を呼びます。

const auto& x = 1 + 2; // P = const U&, A = 1 + 2
                       // f を template<class U> void f(const U& u) としたときの
                       // f(1 + 2) を呼ぶ場合と同じルールが用いられます。
                       // U の推定結果 = int。 x の型は const int& です。
auto l = {13}; // P = std::initializer_list<U>, A = {13}
               // U の推定結果 = int。 l の型は std::initializer_list<int> です。

auto x1 = {3}; // x1 は std::initializer_list<int> です。
auto x2{1, 2}; // エラー、要素が1つではありません。
auto x3{3};    // x3 は int です。
               // (N3922 より前では、 x2 と x3 はどちらも std::initializer_list<int> でした。)

std::string s;
std::getline(std::cin, s); // 「std::getline」は4つの関数テンプレートを表します。
// そのうち2つが候補関数 (引数の数が合っている) です。
// 第1候補:
// P1 = std::basic_istream<CharT, Traits>&, A1 = std::cin
// P2 = std::basic_string<CharT, Traits, Allocator>&, A2 = s
// 推定により型テンプレート引数 CharT、 Traits、および Allocator が決定され、
// 特殊化 std::getline<char, std::char_traits<char>, std::allocator<char>> が生成されます。
// 第2候補:
// P1 = std::basic_istream<CharT, Traits>&&, A1 = std::cin
// P2 = std::basic_string<CharT, Traits, Allocator>&, A2 = s
// 推定により型テンプレート引数 CharT、 Traits、および Allocator が決定され、
// 特殊化 std::getline<char, std::char_traits<char>, std::allocator<char>> が生成されます。
// オーバーロード解決により左辺値 std::cin からの参照束縛が順位付けされ、
// 2つの候補特殊化のうちの1つめが選択されます。

std::cout << std::endl; // std::endl は関数テンプレートを表します。
// endl の型 P =
//   std::basic_ostream<CharT, Traits>& (std::basic_ostream<CharT, Traits>&)
// operator<< の仮引数 A =
//   std::basic_ostream<char, std::char_traits<char>>& (*)(
//     std::basic_ostream<char, std::char_traits<char>>&
//   )
// (operator<< の他のオーバーロードは実行可能ではありません) 
// 推定により型テンプレート引数 CharT および Traits が決定されます。

template<class X> void f(X a);  // 1つめのテンプレート f
template<class X> void f(X* a); // 2つめのテンプレート f
template<> void f<>(int* a) { } // f の明示的実体化
// P1 = void(X), A1 = void(int*): X の推定結果 = int*、すなわち f<int*>(int*)
// P2 = void(X*), A2 = void(int*): X の推定結果 = int、すなわち f<int>(int*)
// そして f<int*>(int*) と f<int>(int*) が半順序付けされ、
// より特殊化されたテンプレートとして f<int>(int*) が選択されます。

struct X
{
    X() { throw std::runtime_error(""); }
    static void* operator new(std::size_t sz, bool b) { return ::operator new(sz); }
    static void* operator new(std::size_t sz, double f) { return ::operator new(sz); }
    template<typename T> static void operator delete(void* ptr, T arg)
    {
        ::operator delete(ptr);
    }
};
 
int main()
{
    try
    {
        X* p1 = new (true) X; // X() が例外を投げた場合、 operator delete が名前探索されます。
                              // P1 = void(void*, T), A1 = void(void*, bool):
                              // T の推定結果 = bool
                              // P2 = void(void*, T), A2 = void(void*, double):
                              // T の推定結果 = double
                              // オーバーロード解決により operator delete<bool> が選択されます。
    } catch(const std::exception&) { }
    try
    {
        X* p1 = new (13.2) X; // 同様に名前探索され、 operator delete<double> が選択されます。
    } catch(const std::exception&) { }
}

template<class T> struct Alloc { };
template<class T> using Vec = vector<T, Alloc<T>>;
Vec<int> v;
 
template<template<class, class> class TT> void g(TT<int, Alloc<int>>);
g(v); // OK: TT の推定結果 = vector
 
template<template<class> class TT> void f(TT<int>);
f(v); // エラー、 Vec はエイリアステンプレートであるため TT は「Vec」として推定できません。