C++学习笔记--函数模板

泛型编程就是不考虑具体数据类型的编程方式。而C++中存在一种泛型编程方式，函数模板。函数模板是一种特殊的函数可用不同类型进行调用，看起来和普通函数很相似，区别是类型可被参数化，形如下面：

template < typename T >
void Swap(T& a, T& b)
{
    T c = a;
    a = b;
    b = c;
}

其中， template关键字用于声明开始进行泛型编程，typename关键字用于声明泛指类型，如上面函数模板中的T就是一个泛指类型。

函数模板的调用：

编译器可以进行自动类型推导调用，根据实参类型推导参数类型，如：Swap(a,b);

可以具体类型显式调用，如：Swap<float>(c,d)。

函数模板的意义在于代码复用。

函数模板深入理解

编译器通过具体类型从函数模板中产生不同的函数。

编译器会对函数模板进行两次编译，首先会对模板代码本身进行编译，然后对参数替换后的代码进行编译。

注意事项：

函数模板本身不允许隐式类型转换，自动推导类型时，必须严格匹配；显式指定类型时，能够进行隐式类型转换。

下面开始证明：

1、故意使函数模板中产生一个语法错误，发现编译会出错，证明编译器确实会对函数模板代码本身进行编译。

2、证明编译器会对替换后的代码再次进行编译。

首先定义两个与函数模板能够匹配的函数指针：

typedef void(FuncI)(int&, int&);
typedef void(FuncD)(double&, double&);

指行下面语句;

    FuncI* pi = Swap;    // 编译器自动推导 T 为 int
    FuncD* pd = Swap;    // 编译器自动推导 T 为 double

再打印pi和pd地址：

    cout << "pi = " << reinterpret_cast<void*>(pi) << endl;
    cout << "pd = " << reinterpret_cast<void*>(pd) << endl;

输出结果：

pi = 0x420144
pd = 0x420110

显然，编译器在对函数进行编译时，不同的函数存放在不同地址，所以编译器会对替换后的代码再次进行编译。（还有个更好的证明方法，就是定义一个类，将拷贝构造函数作为私有级别，再通过拷贝构造来初始化，会发现 编译器报错，由于原先的函数模板编译是正确的，所以只能是再次编译时出错。）

多参数函数模板

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

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

对于多参数函数模板无法自动推导 返回值类型，可以从左往右部分指定参数类型，但是 必须指定返回值类型，工程中我们将第一个类型参数作为返回值参数。

    // 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);

第一组只指定了返回值类型，也是必须的，函数参数由编译器自动推导；第二组第三组较之第一组多了对函数参数作了类型指定。

函数模板重载

函数模板可以像普通函数一样被重载，但是在调用过程会根据规则调用：

C++编译器优先考虑普通函数，如果函数模板可以生成一个更好的匹配，那么将选择模板进行调用，为了限定编译器只通过匹配模板调用可以通过空模板实参列表限定，如：

Max<>(a, b);//编译器只能通过模板匹配

定义一个函数模板重载：

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)
{
    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 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)