C++中函数模板的深入理解

1，函数模板深入理解：

    1，编译器从函数模板通过具体类型产生不同的函数；

       1，模板就是模子，通过这个模子可以产生很多的实物；

       2，函数模板就是编译器用来产生具体函数的模子；

    2，编译器会对函数模板进行两次编译：

       1，对模板代码本身进行编译；

           1，检查函数模板本身有无语法错误等；

       2，对参数替换后的代码进行编译；

           1，调用函数模板的时候，编译器要根据实际的参数类型得到真正的函数，这个时候编译器会对这个函数进行第二次编译；

      

2，注意事项：

    1，函数模板本身不允许隐式类型转换：

       1，自动推导类型时，必须严格匹配；

           1，函数模板本身不是函数，它只是产生函数的模子，因此函数模板本身不允许隐式类型转换；

       2，显示类型指定时，能够进行隐式类型转换；

           1，显示指定类型，就会得到真实的函数，这个时候有可能进行隐式类型转换；

                 

3，函数模板的本质编程实验：

#include <iostream>
#include <string>

using namespace std;

class Test
{
    Test(const Test&);
public:
    Test()
    {
    }
};

template < typename T >
void Swap(T& a, T& b)  // 这里编译器显示为: In function 'void Swap(T&, T&)'；说明这也是函数，是模板函数；
{
    T c = a;
    // a = b  // 当文件中只有类模板一个参数时，编译器显示：error: expected ';' before 'b'；证明了编译器还是会对模板本生进行编译；
    a = b;  
    b = c;
}

typedef void(FuncI)(int&, int&);  // 定义函数类型，类型名为 FuncI； 
typedef void(FuncD)(double&, double&);
typedef void(FuncT)(Test&, Test&);

int main()
{
    /* pi 和 pd 指向具体函数，但是 pi 和 pd 指向的具体函数是由函数模板具体产生，这里已经产生了函数，不是模板了，这两个函数是两个独立的不同的函数 */
    FuncI* pi = Swap;    // 定义函数指针，并能编译通过；这里编译器通过函数指针的类型自动推导 T 为 int； 编译器默默做的事有：1，首先进行自动推导；2，产生真正的 Swap() 函数；3，将实际生成的 Swap() 函数地址用于初始化 pi；

    FuncD* pd = Swap;    // 编译器自动推导 T 为 double；
    
    /* 证明编译器做了第二次编译 */
    FuncT* pt = Swap;    // 没有显示声明拷贝构造函数时，编译器自动推导 T 为 Test；
    // FuncT* pt = Swap;  // 编译器显示：instantiated from here  
                          //  error: 'Test::Test(const Test&)' is private
                          //  error: within this context（也就是 Swap 中 T c = a; 语句）；
                          // 这里的编译错误是二次编译时发现的，自动推导 T 为 Test 后，会产生一个 Swap() 函数，接下来会对 Swap() 函数进行编译，接下来就发现 T c = a; 行有问题；
    
    cout << "pi = " << reinterpret_cast<void*>(pi) << endl;   // 将 pi 这个指针的类型重解释为 void*；打印：0x80487a8；
    cout << "pd = " << reinterpret_cast<void*>(pd) << endl;  // 打印：0x80487ca；
    cout << "pt = " << reinterpret_cast<void*>(pt) << endl;  // 没有显示声明拷贝构造函数时，打印：0x8048828；
    // cout << "pt = " << reinterpret_cast<void*>(pt) << endl;  
    
    return 0;
}

   

4，多参数函数模板：

    1，函数模板可以定义任意多个不同的类型参数：

       1，代码示例：

template < typename T1, typename T2, typename T3 >
T1 Add(T2 a, T3 b)
{
    return static_cast<T1>(a + b);
}
           
int r = Add<int, float, double>(0.5, 0.8);

       2，仅仅是调用的时候多了几个泛指类型而已；

    2，对于多参数函数模板：

       1，无法自动推导返回值类型；

           1，只有返回值类型必须手工的指定；

           2，一般的工程中指定第一个模板参数为返回值类型；

       2，可以从左向右部分指定函数类型参数：

 

           1，剩下的参数类型编译器可以自动推导；

       3，工程中，将返回值参数作为第一个类型参数；

           1，返回值是泛指类型，则将第一个类型参数作为返回值类型；

           2，这是工程中手动设置的，并不是编译器自己的行为；

      

5，多参数函数模板编程实验：

#include <iostream>
#include <string>

using namespace std;

template 
< typename T1, typename T2, typename T3 >
T1 Add(T2 a, T3 b)
{
    return static_cast<T1>(a + b);
}


int main()
{
    // T1 = int, T2 = double, T3 = double
    int r1 = Add<int>(0.5, 0.8);

    // T1 = double, T2 = float, T3 = double
    double r2 = Add<double, float>(0.5, 0.8);

    // T1 = float, T2 = float, T3 = float
    float r3 = Add<float, float, float>(0.5, 0.8);

    cout << "r1 = " << r1 << endl;     // r1 = 1
    cout << "r2 = " << r2 << endl;     // r2 = 1.3
    cout << "r3 = " << r3 << endl;     // r3 = 1.3
    
    return 0;
}

   

6，当函数重载遇见函数模板会发生什么？

    1，见下本文7 中的分析；

 

7，重载函数模板：

    1，函数模板可以像普通函数一样被重载：

       1，C++ 编译器优先考虑普通函数；

       2，如果函数模板可以产生一个更好的匹配，那么选择模板；

       3，可以通过空模板实参列表限定编译器只匹配模板：

 

          

8，重载函数模板实例分析：

#include <iostream>
#include <string>

using namespace std;

template < typename T >
T Max(T a, T b)
{
    cout << "T Max(T a, T b)" << endl;
    
    return a > b ? a : b;
}

int Max(int a, int b)  // C++ 中这个函数可以重载上面的模板；
{
    cout << "int Max(int a, int b)" << endl;
    
    return a > b ? a : b;
}

template < typename T >
T Max(T a, T b, T c)
{
    cout << "T Max(T a, T b, T c)" << endl;
    
    return Max(Max(a, b), c);  // 这里是重载的模板；
}

int main()
{
    int a = 1;
    int b = 2;
    
    cout << Max(a, b) << endl;   // 普通函数 Max(int, int)
    
    cout << Max<>(a, b) << endl;  // 函数模板 Max<int>(int, int)
    
    cout << Max(3.0, 4.0) << endl;  // 函数模板 Max<double>(double,double)
    
    cout << Max(5.0, 6.0, 7.0) << endl;  // 函数模板 Max<double>(double, double, double)
    
    cout << Max('a', 100) << endl;    // 普通函数 Max(int, int)；函数模板是不会进行隐式类型转换的，因此这时不会考虑上述两个模板进行隐式推导，这里直接考虑普通函数并进行隐式类型转换；
    
    return 0;
}

   

9，小结：

    1，函数模板通过具体类型产生不同的函数；

    2，函数模板可以定义任意多个不同的类型参数；

    3，函数模板中的返回值类型必须显示指定；

    4，函数模板可以像普通函数一样被重载；