C++中的模板技术

问题引入：C++中有几种交换变量的方法？

1、定义宏代码块。优点：代码复用，适合所有类型；缺点：编译器不知道宏的存在，缺少类型检查。 

2、定义函数。优点：真正的函数调用，编译器对类型进行检查；缺点：根据类型重复定义函数，无法代码复用。

泛型编程——函数模板：

一种特殊的函数，可用不同的类型进行调用，与普通函数的区别在于，类型可以被参数化。

template关键字，用于声明开始进行泛型编程；

typename关键字用于声明繁殖类型。

实现代码如下：

#include <iostream>
#include <string>

using namespace std;

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

template < typename T >
void Sort(T a[], int len)
{
    for(int i=0; i<len; i++)
    {
        for(int j=i; j<len; j++)
        {
            if( a[i] > a[j] )
            {
                Swap(a[i], a[j]);
            }
        }
    }
}

template < typename T >
void Println(T a[], int len)
{
    for(int i=0; i<len; i++)
    {
        cout << a[i] << ", ";
    }
    
    cout << endl;
}

int main()
{
    int a[5] = {5, 3, 2, 4, 1};
    
    Println(a, 5);
    Sort(a, 5);
    Println(a, 5);
    
    string s[5] = {"Java", "C++", "Pascal", "Ruby", "Basic"};
    
    Println(s, 5);
    Sort(s, 5);
    Println(s, 5);
    
    return 0;
}

C++通过函数模板，实现了对代码的复用。（复用代码的方式还有继承和包含）

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

编译器会对函数模板进行两次编译：第一次是对函数模板代码本身进行编译，第二次是对参数替换后的代码进行编译。注：模板本身并不支持隐式类型转换，自动推到类型时，必须严格匹配，显式类型指定时，可以进行隐式类型转换。

函数模板可以定义任意多个不同的类型参数，但无法自动推导返回值类型。

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

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

C++编译器优先考虑普通函数，如果函数模板可以产生一个更好的匹配，那么选择模板。

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

举例如下：

#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)
{
    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;
}

类模板

C++中，容器类主要用来设计用来存储其他对象或数据类型。比如：数组类、链表类、Stack类、Queue类，等。类中数据组织的方式和数据元素的具体类型无关。

C++的类模板为生成通用的类声明提供了一种更好的方法。模板提供参数化类型，即能够将类型名作为参数传递给接收方来建立类或函数。例如，将类型名int传递给Queue模板，可以让编译器构造一个对int进行排队的Queue类。即以相同的方式处理不同的类型数据。

实现代码如下：

#include <iostream>
#include <string>

using namespace std;

template < typename T >
class Operator
{
public:
    T add(T a, T b)
    {
        return a + b;
    }
    T minus(T a, T b)
    {
        return a - b;
    }
    T multiply(T a, T b)
    {
        return a * b;
    }
    T divide(T a, T b)
    {
        return a / b;
    }
};

string operator-(string& l, string& r)
{
    return "Minus";
}

int main()
{
    Operator<int> op1;
    
    cout << op1.add(1, 2) << endl;
    
    Operator<string> op2;
    
    cout << op2.add("D.T.", "Software") << endl;
    cout << op2.minus("D.T", "Software") << endl;
    
    return 0;
}

编译器对类模板的处理方式和函数模板相同，对模板代码先编译一次，再对替换后的代码编译一次。

注意：类模板必须在头文件中定义，切不能分开实现在不同的文件中。类模板外部定义的成员函数需要加上“模板<>”声明，即在使用的时候必须显式指定类型。

#ifndef _OPERATOR_H_
#define _OPERATOR_H_

template < typename T >
class Operator
{
public:
    T add(T a, T b);
    T minus(T a, T b);
    T multiply(T a, T b);
    T divide(T a, T b);
};

template < typename T >
T Operator<T>::add(T a, T b)
{
    return a + b;
}


template < typename T >
T Operator<T>::minus(T a, T b)
{
    return a - b;
}


template < typename T >
T Operator<T>::multiply(T a, T b)
{
    return a * b;
}


template < typename T >
T Operator<T>::divide(T a, T b)
{
    return a / b;
}

#endif

CPP代码如下：

#include <iostream>
#include <string>
#include "Operator.h"

using namespace std;

int main()
{
    Operator<int> op1;
    
    cout << op1.add(1, 2) << endl;
    cout << op1.multiply(4, 5) << endl;
    cout << op1.minus(5, 6) << endl;
    cout << op1.divide(10, 5) << endl;
    
    return 0;
}

类模板可以被特化。即指导类模板的特定实现，将部分类型参数显式指定，根据类型参数，分开实现类模板。

部分特化：用特定规则约束类型参数；

完全特化：完全显式指定类型参数。

注：函数模板只支持完全特化。

重定义与特化的不同：

重定义：生成一个新的类模板和一个新类型，使用的时候要考虑如何选择；

特化：以统一的方式使用类模板和特化类型，编译器会自动优先选择特化类型。

template
< typename T >    //函数模板定义
bool Equal(T a, T b)
{
    cout << "bool Equal(T a, T b)" << endl;
    
    return a == b;
}

template
< >
bool Equal<double>(double a, double b)   //完全特化
{
    const double delta = 0.00000000000001;
    double r = a - b;
    
    cout << "bool Equal<double>(double a, double b)" << endl;
    
    return (-delta < r) && (r < delta);
}

工程建议：当需要重载函数模板时，优先考虑使用模板特化，当模板特化不满足需求时，再使用函数重载。