【C++】第10章：类模板-模板的全特化和偏特化及模板的分离编译

【C++】第10章：类模板-模板的全特化和偏特化及模板的分离编译

一、非类型模板参数

模板参数分类为两种：类型形参与非类型形参。

类型形参：出现在模板参数列表中，标有关键字class或者typename的参数类型名称，也就是我们最常见的模板参数列表中的参数。

非类型形参：就是用一个常量作为类(函数)模板的一个参数。这种方式不常用，所以需要注意一下。注意：通常常量为整形类型。

举个例子：

template<class T, size_t N = 10> // 第一个参数为T类型，第二个参数是一个有缺省值的整型值	
class Array {
public:
    T array[N]; // 可以使用模板参数列表中的参数
};

注意：

1.模板参数列表中除了class和typename关键字之外，只能出现整型类型的参数作为常量，而浮点数，类对象等等都不能作为模板的参数。

2.非类型的模板参数都必须在编译器就能确定结果，即模板不能分离编译（后面会介绍）。

二、模板的特化

1.为什么会有模板特化？

首先在我们使用模板的特化之前，我们需要搞清楚为什么会出现模板的特化，即模板特化的出现是为了解决什么问题？

我们首先来写一个例子，看看这样写出的模板是不是存在一定的问题。

template<class T>
bool equal(const T& a, const T& b) {
    return a == b;
}

int main() {
    int a = 10, b = 10, c = 20;
    cout << equal(a, b) << endl; // 输出1，表示真
    cout << equal(a, c) << endl; // 输出0，表示假
    char s1[] = "hello";
    char s2[] = "hello";
    cout << equal(s1, s2) << endl; // 输出0，表示假，???
    return 0;
}

在上面的例子中，用模板写了一个比较相等的函数模板。同时也写了一个测试代码。

当在比较两个整型的时候可以正常的输出。但是在比较两个char []数组的时候，输出的答案和我们的预期缺失不一样的。

这是因为数组名代表的是数组的地址，而两个char数组中虽然存放的内容（hello字符串）是相同的，但是在比较的时候，比较的是两个数组的地址。而如果比较地址的话，因为两个数组在栈上开辟的内存一定是在不同的地方上，所以数组的地址也一定是不一样的，所以输出false。

为了解决这个问题，我们只能使用strcmp这个c标准库中的函数来比较字符数组中的内容。但是除了字符串数组之外，在比较其他的内容的时候，一般还是使用==比较。那该怎么办呢？

（回答：）为了解决在处理模板这种泛化编程中的特例的时候，我们可以使用模板的特化，换言之，就是对于模板中的某一个类型参数进行特殊的针对性的人为的重写代码，这种对于泛型编程中的特殊处理就叫做模板的特化。

2.模板的特化及偏特化

模板有两种：函数模板和类模板，所以模板就有函数模板的特化和类模板的特化。但是两种模板特化的书写形式都是类似的。

2.1 函数模板的特化

函数模板特化的步骤：

1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同

我们就接着上面比较函数模板的例子继续写下去。

//对于char*类型的特化
template<>
bool equal<const char* const>(const char* const &a, const char* const &b) {
    return strcmp(a, b) == 0;
}

**补充：**一般函数模板如果需要特化的情况不是很多，但是如果想要特化版本的实现就会比普通的函数模板要复杂一点。所以一般函数模板的特化我们不适用函数模板。因为函数的特性是会优先调用函数参数更相匹配的函数，所以我们可以使用一个具体的函数来替代特化版本的函数模板。

即：

template<class T>
bool equal(const T& a, const T& b) {
    return a == b;
}

bool equal(char* a, char* b) {
    return strcmp(a, b);
}

int main() {
    char a[] = "hello";
    char b[] = "hello";
    cout << equal(a, b) << endl; // 优先调用实体的函数，而不是函数模板
    return 0;
}

2.2 类模板的特化及偏特化

因为类模板中常常处理的问题比较复杂，所以也会遇到模板特化的结果。

举个例子：

template<class T1, class T2>
class Complex {
public:
    Complex() {
        cout << "<T1, T2>" << endl;
    }
private:
    T1 a;
    T2 b;
};

template<>
class Complex<int, int> { // 特化版本的<int, int>
public:
    Complex() {
        cout << "<int, int>" << endl;
    }
private:
    int a;
    int b;
};

template<>
class Complex<int ,double> { // 特化版本的<int, double>
public:
    Complex() {
        cout << "<int, double>" << endl;
    }
private:
    int a;
    double b;
};

int main() {
    Complex<char, char>(); // 输出<T1, T2>
    Complex<int, int>();   // 输出<int, int>
    Complex<int, double>();// 除数<int, double>
    return 0;
}

除了模板的特化，还有类模板的偏特化（函数模板也有，但是因为函数模板的特化和偏特化实在是不常用就不举例子了）。理解了模板的特化，模板的偏特化就会比较好理解了，即不是所有的模板参数列表中的参数都特化，而是列表中的部分参数需要特殊的处理，或者是对于某一个T类型参数都指针T*或者引用T&的特殊版本。

举个例子：

1.部分特化

将模板的参数列表中的部分类型参数换成具体的类型。

template<class T>
class Complex<T, int> {
public:
    Complex() {
        cout << "<T, int>" << endl;
    }
private:
    T a;
    int b;
}

int main() {
    Complex<char, int>(); // 输出<T, int>
    return 0;
}

2.参数限制

将模板的参数列表中的泛型参数T换成引用类型T&或者是指针类型T*。（注意：T&或者T*只是对类型进行了之中限制，而不是一个新的类型，但是同样是一个进行了特化处理的类）

template<class T1, class T2>
class Complex<T1&, T2&> {
public:
    Complex() {
        cout << "<T1&, T2&>" << endl;
    }
private:
    T1 a;
    T2 b;
};


template<class T1, class T2>
class Complex<T1*, T2*> {
public:
    Complex() {
        cout << "<T1*, T2*>" << endl;
    }
private:
    T1 a;
    T2 b;
};

int main() {
    Complex<int*, int*>(); // 输出<T1*, T2*> 
    Complex<int&, int&>(); // 输出<T1&, T2&
    return 0;
}

三、模板的分离编译

1.是什么分离编译？

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链 接起来形成单一的可执行文件的过程称为分离编译模式。

举个例子：

//---------------test.h----------------//
void func();//这里声明一个函数f

//---------------test.cpp--------------//
#include”test.h”
void func() {
	cout << "hello world" << endl;//这里实现出test.h中声明的func函数
} 

//---------------main.cpp--------------//
#include”test.h”
int main() {
	func(); //调用func，func具有外部连接类型
}

2.分析模板为什么不能分离编译

要搞清楚为什么模板不能分离编译，就要搞清楚费力编译中每一步都做了什么？

在这里我们就以上面例子，说明分离编译中发生了什么，然后对比说明为什么模板不能分离编译。

首先我们需要知道程序运行需要经过四步：

1.预处理：头文件展开，去注释，宏替换，条件编译等。

2.编译：检查代码是否存在语法错误，如果没有错误将代码转化为汇编代码。

3.汇编：将汇编代码转化为二进制的机器码，生成.obj文件（在Linux下生成.o文件）

4.链接：将所有.obj文件链接在一起生成可执行程序。

在上面的test.h，test.cpp，main.cpp这个条件编译的例子中。test.cpp和main.cpp最会都在经过汇编之后生成了.obj文件。在main.cpp生成.obj文件的时候，main.cpp中其实并没有test.cpp中的func函数的代码，只有等到两个.obj文件链接到一起的时候才可以实际的调用到。在这之前，main.cpp中只有func函数的声明。也就是告诉编译器先不要报错等到链接的时候，就会找到函数的实现了。所以在底层形成汇编代码的时候，调用函数的指令为call命令，只能call ?????，这里的????就是等待实现func函数的地址，等到链接的时候，编译器找到了函数的时候，就是call func的地址。

了解完了常规的条件编译，下面来康康模板的条件编译：

还是哪一个例子说明：

//-------------test.h----------------//
template<class T>
class A
{
public:
	void func(); // 这里只是个声明
};

//---------------test.cpp-------------//
#include”test.h”
template<class T>
void A<T>::func()  // 模板的实现
{
  	cout << "hello world" << endl;
}

//---------------main.cpp---------------//
#include”test.h”
int main()
{
	A<int> a;
	a.func(); // 调用func()函数
}

模板不能条件编译的原因在于：模板在经过预处理，编译，汇编之后，只能产生main.obj这一个目标文件，而不能产生test.obj目标文件。

这是因为如果一个模板不能实例化调用的话，模板是不会编译出来一份模板类的。 这是C++标准明确表示，当一个模板不被用到的时侯它就不该被实例化出来

而在test.cpp这个文件中并没有实例化，所以模板就不会主动的生成一份模板类。所以在链接的时候，main.cpp中call指令在其他的.obj文件中寻找func()函数地址的时候并没有找到，导致最后就没能成功的调用func函数，因而不能链接生成可执行程序。

总结原因：在test.cpp中定义的地方不能实例化，在main.cpp中声明的地方没有函数的定义。所以不能形成可执行程序

3.如何解决模板不能分离编译的问题

有两种方法可以解决这个问题：

方法一：可以在test.cpp，就是函数定义的地方主动的实例化。也就是如果想要调用<int>类型的函数就显示的实例化出来。

template<>
class A<int> {
public:
    void func() {
        cout << "hello world" << endl;
    }
};

但是一般不推荐这样写，因为这样写太麻烦了，这就又回到了原来没有用模板类的状态吗，还是有手动的一个一个写出来。

方法二：可以在test.h，即模板声明的地方直接实现函数，这样就相当于直接在原处理的时候，就将所有的代码都拷贝到main.cpp中了，这样模板就可以实例化了。（推荐使用，STL库中都是这样写的）

四、模板的总结

优点：

1. STL库中使用了模板的概念，使得模板复用了代码，节省资源，更快的迭代开发。
2. 增强了代码的灵活性。

缺陷：

1. 模板会导致代码膨胀问题，也会导致编译时间变长。
2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误。