模板实参推导

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)
                                // 并将它的地址储存在 ptr
}

#include <iostream>
 
int main()
{
    std::cout << "Hello, world" << std::endl;
    // operator<< 通过 ADL 查找为 std::operator<<，
    // 然后两次都推导为 operator<<<char, std::char_traits<char>>
    // 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;  // 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>
           // struct X 的模板声明中形参类型是 int&
           // 实参类型是 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>)

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 绑定的引用排在高位
// 并选取两个候选特化的第一个

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); // 错误：TT 无法被推导为 "Vec"，因为 Vec 是别名模版

template<class T>
struct Z { typedef typename T::x xx; };
 
template<class T>
typename Z<T>::xx f(void*, T); // #1
 
template<class T>
void f(int, T);                // #2
 
struct A {} a;
 
int main()
{
    f(1, a); // 对于 #1，推导确定 T = struct A，但剩余实参 1
             // 不能隐式转换成其形参 void*：推导失败
             // 不要求返回类型的实例化
             // 对于 #2，推导确定 T = struct A，且剩余实参 1
             // 能隐式转换成其形参 int：推导成功
             // 函数调用编译为到 #2 的调用（推导失败是 SFINAE）
}