Step By Step(C++模板推演)

    普通重载函数可以通过函数参数进行推演，并由编译器选定最适合的重载函数作为候选函数。与此类似，模板函数可以通过函数参数的类型推演出该函数模参的实际类型。C++的编译器在完成类型推演的过程中有以下一些技巧和注意事项，这里我们将尽可能的列出最为常用的规则，并给出相应的示例以便于理解。
    1. 最基本的模板函数类型推演。见以下代码示例、关键性注释和输出结果。

    #include <stdio.h>
    #include <typeinfo.h>
    
    template<typename T>
    void func1(T* t) {
        printf("The type is %s\n",typeid(t).name());
    }
    
    template<typename T,int N>
    void func2(T(&)[N]) {
        printf("The type of T is %s, N equals to %d.\n",typeid(T).name(),N);
    }
    
    template<typename T1,typename T2,typename T3>
    void func3(T1 (T2::*)(T3*)) {
        printf("The type of T1 is %s\n",typeid(T1).name());
        printf("The type of T2 is %s\n",typeid(T2).name());
        printf("The type of T3 is %s\n",typeid(T3).name());
    }
    
    template<int N>
    class TemplateTest {
    public:
        typedef int INT;
        void f(int) {}
    };
    
    template<int N>
    void func4(void (TemplateTest<N>::*p)(typename TemplateTest<N>::INT) ) {
        printf("N equals to %d\n",N);
    }
    
    class Test {
    public:
        void f(double*) {}
    };
    
    int main() {
        int** pp = NULL;
        func1(pp); //T的类型为int*
    
        bool b[100];
        func2(b);  //T的类型为bool，N的值是100
    
        func3(&Test::f); //T1：void，T2：class Test，T3：double。
    
        func4(&TemplateTest<200>::f);
        return 0;
    }
    //The type is int * *
    //The type of T is bool, N equals to 100.
    //The type of T1 is void
    //The type of T2 is class Test
    //The type of T3 is double
    //N equals to 200

    2. 如果函数参数为T&(引用类型)，其模参类型仍为T。

    #include <stdio.h>
    #include <typeinfo.h>
    
    template<typename T>
    void func(T& s) {
        printf("The type is %s\n",typeid(s).name());
    }
    
    int main() {
        int k = 0;
        func(k);
        return 0;
    }
    //The type is int

    从输出结果可以看出，T的实际类型仍为int，而非int&。
        
    3. 如果函数参数为引用类型，而函数的实参则为数组或函数类型，那么将不会进行任何隐式转换。如参数不为引用类型，在此种情况下将会产生从数组到指针和函数到函数指针的隐式类型转换。

    #include <stdio.h>
    #include <typeinfo.h>
    
    template<typename T>
    void func(T const& s) {
        printf("The type is %s\n",typeid(s).name());
    }
    
    template<typename T>
    void func2(T s) {
        printf("The type is %s\n",typeid(s).name());
    }
    
    int main() {
        int k[5];
        func(k);
        func2(k);
        return 0;
    }
    //The type is int const [5]
    //The type is int *

    从输出结果可以看出，引用类型的函数参数仍然保持了数组类型，而非引用类型的函数则将实参的类型转换为指针类型。
        
    4. 模板推演的几个特殊示例。

    #include <stdio.h>
    #include <typeinfo.h>
    
    template<typename T>
    void func(T) {
        printf("The type is %s\n",typeid(T).name());
    }
    
    void (*pf)(char) = &func; //在本次赋值中完成了类型推演。
    
    int main() {
        pf('A');
        return 0;
    }
    //The type is char

    5. 如果在推演的过程中没有找到精确匹配，然而函数参数是基类类型(或指针)，当实参为派生类类型(或指针)时，推演仍可成功。

    #include <stdio.h>
    #include <typeinfo.h>
    
    template<typename T>
    class Base {
    };
    
    template<typename T>
    class Derive : public Base<T> {
    };
    
    template<typename T>
    void func(Base<T>*) {
        printf("The type of T is %s.\n",typeid(T).name());
        printf("The type of Base<T> is %s.\n",typeid(Base<T>).name());
    }
    
    int main() {
        Derive<int> d;
        func(&d);
        return 0;
    }
    //The type of T is int.
    //The type of Base<T> is class Base<int>.

    从上述输出结果中可以看出，T的类型被成功推演，即便func函数的实参为Derive<int>(Base<int>的派生类)。
    
    6. 函数的缺省参数不能参与类型推演。

    #include <stdio.h>
    
    template<typename T>
    void func(T x = 100) {
    
    }
    
    int main() {
        func<int>(); //这里显示的指定了函数的模参类型，因此可以通过编译。
        func(100);   //通过实参的类型推演出函数模参的类型，也可以通过编译。
        func();         //不能因为函数参数的缺省值是100，就可以利用该规则推演模参类型，不同通过编译。
        return 0;
    }