C++模板：非类型模板参数、模板特化及模板的分离编译

【Shine】光芒

于 2023-04-06 16:31:45 发布

阅读量481

点赞数 5

分类专栏： C++从入门到精通文章标签： c++ 开发语言模板

本文链接：https://blog.csdn.net/weixin_43908419/article/details/129988155

版权

C++从入门到精通专栏收录该内容

45 篇文章 6 订阅

订阅专栏

一. 非类型模板参数

为了支持泛型编程，C++引入了模板的概念，一般情况下，模板使用在函数或类中，在调用函数或创建类对象时，编译器会推导模板参数所代表的类型，从而实例化出特定的函数或类。

然而，模板参数并不一定是类型参数，还有可能是非类型参数，非类型模板参数在函数或类中作为整形常量来使用。

类型模板参数：声明在模板参数列表中，前面跟class或typename，在使用时被实例化为具体的数据类型，如int、char、double或自定义类型等。
非类型模板参数：在函数或类中作为整形常量来使用。

演示代码1.1展示了非类型模板参数的使用方法，代码中定义了一个名为Stack的类模板，其中的一个模板参数为N，N表示无符号整形常量，如果不显示地给定N的值，那么N默认为10。

template <class T, size_t N = 10>
class Stack
{
public:
	Stack()  //构造函数
		: _size(N)
	{ }

private:
	T _a[N];
	size_t _size;
};

关于非类型模板参数的两点注意事项：

非类型模板参数必须是整形常量，如float、double、string、自定义类型数据等，都不可以作为非类型模板参数来使用。
非类型模板参数必须在编译时就能知道值是多少，即：必须给定默认值或显示传值。

二. 模板的特化

模板的特化，即针对特殊类型模板参数的特殊处理，函数模板和类模板都可以进行特化处理。

2.1 函数模板的特化

函数模板特化可以让函数针对特殊类型的传入参数，进行特殊的处理，函数模板特化要进行如下操作：

要有函数的基础模板，即没有特化的版本。
定义特化函数：template<> 函数名<特殊参数类型> {...函数指令...}。这里一定要注意，在定义特化函数前要先输入template<>指令，尖括号<>内部为空，函数名后面的尖括号内部需要指定特化的模板参数类型。

演示代码2.1定义了用于进行小于比较的函数模板objLess，并针对Date*类型的参数进行特化，如果在调用函数时传入两个类型为Date*的参数，那么就对它们解引用后的对象进行小于比较。

演示代码2.1：

template<class T>
bool objLess(T x, T y)
{
	return x < y;
}

template<> 
bool objLess<Date*>(Date* d1, Date* d2)  //针对Date*类型的特化版本
{
	return *d1 < *d2;
}

但是，函数模板特化并没有多少实际意义，因为，可以直接定义函数的重载形式，来实现对特定类型的特殊处理，如演示代码2.2所示，直接声明并定义函数bool objLess(Date* d1, Date* d2)达到了与演示代码2.1中的函数模板特化一样的效果。

演示代码2.2：

template<class T>
bool objLess(T x, T y)
{
	return x < y;
}

bool objLess(Date* d1, Date* d2)
{
	return *d1 < *d2;
}

综上，我们可以认为，函数模板特化其实就是参数匹配的过程，所实现的功能与函数重载几乎一致，一般的项目中，极少使用函数模板特化。

2.2 类模板的特化

2.2.1 全特化

全特化就是模板参数列表中的所有模板参数都确定化。如定义模板类template<class T1, class T2> class A{...}，需要对T1为char及T2为int的情况进行特殊化处理，就可以给出A的特化版本：

template<> A<int, char> { ... }

对于类模板特化，需要下面的步骤：

定义原始的类模板
template后面跟没有内容的尖括号<>，这可以视为是对类（函数）模板特化的声明。
在template<>后面跟类名<特化模板参数类型>，定义具体特化后的类模板。

演示代码2.3：

template<class T1, class T2>
class A
{
public:
	A()
	{
		std::cout << "A<T1, T2>" << std::endl;
	}
};

//针对模板参数类型为char、int的重载
template<>
class A<char, int>
{
public:
	A()
	{
		std::cout << "A<char, int>" << std::endl;
	}
};

int main()
{
	A<int, int> a1;    //A<T1, T2>
	A<int, double> a2; //A<T1, T2>
	A<char, int> a3;   //A<char, int>
	return 0;
}

2.2.2 偏特化

偏特化指任何针对模板参数的进一步限制的特化版本。偏特化可分为两种类型：部分参数确定化、对于类型的进一步限制。

部分模板参数确定化

template<class T1, class T2>
class A
{
public:
	A()
	{
		std::cout << "A<T1, T2>" << std::endl;
	}
};

//部分偏特化：限制第一个模板参数类型，第二个任意
template<class T2>
class A<char, T2>
{
public:
	A()
	{
		std::cout << "A<char, T2>" << std::endl;
	}
};

int main()
{
	A<int, int> a1;    //A<T1, T2>
	A<char, double> a2; //A<char, T2>
	A<char, int> a3;   //A<char, T2>
	return 0;
}

对于模板参数类型的进一步限制 -- 如针对指针或引用类型的特化

template <class T1, class T2>
class A
{
public:
	A()
	{
		std::cout << "A<T1, T2>" << std::endl;
	}
};

//对于指针类型参数的特化
template<class T1, class T2>
class A<T1*, T2*>
{
public:
	A()
	{
		std::cout << "A<T1*, T2*>" << std::endl;
	}
};

//对于引用类型参数的特化
template<class T1, class T2>
class A<T1&, T2&>
{
public:
	A()
	{
		std::cout << "A<T1&, T2&>" << std::endl;
	}
};

int main()
{
	int x = 10, y = 20;
	A<int, int> a1;    //A<T1, T2>
	A<int*, int*> a2;  //A<T1*, T2*>
	A<int&, int&> a3;  //A<T1&, T2&>
	return 0;
}

三. 模板的分离编译

3.1 什么是分离编译

分离编译就是一个程序或项目由多个源文件组成，每个源文件经过编译后生成对应的目标文件，经过链接，多个目标文件生成单一的可执行程序。

函数或类的声明和定义在不同的文件中，可认为是一种分离编译。

模板不支持分离编译，即：不支持函数模板或类模板在.h文件中声明，在.cpp文件中编译。

3.2 为什么模板不支持分离编译

要弄明白为什么模板不能分离编译，首先要明白程序编译的过程。由源文件生成可执行程序，要经历编译和链接两个过程，其中编译过程又可以分为预编译、编译和汇编三个小过程。

预编译：完成头文件的包含、注释的删除、对条件编译的处理以及宏的替换。
编译：进行语法检查，将C/C++代码转变为对应的汇编代码，同时进行符号汇总。
汇编：将汇编代码转换为机器可以识别的二进制指令（机器码），同时生成符号表。
链接：将多个目标文件与链接库进行链接，进行合并段表、符号表的合并和重定位操作。

对于函数模板和类模板，因为不知道模板参数的具体类型，所以函数或类不会被实例化，在链接阶段不会对函数或类模板的定义的代码进行编译，因此，在链接阶段去寻找函数或类定义的具体地址时就无法找到，从而引发链接错误。

3.3 模板不支持分离编译的解决办法

方法1：显示实例化

函数模板和类模板都可以显示地进行实例化，对于类模板，既可以显示实例化整个类，也可以单独显示实例化某个成员函数。

由于显示实例化很大程度上失去了泛型编程的意义，因此这种方法几乎不用。

演示代码3.1：（显示实例化函数模板和类模板）

//func.h文件 -- 函数模板和类模板的声明
template <class T>
void func1(const T& x);   //函数模板的声明

template<class T>
class AA   //类模板的声明
{
public:
	AA();
};

//func.cpp -- 定义函数模板及类模板成员函数 + 显示实例化
#include "func.h"
//定义函数模板
template <class T>
void func1(const T& x)
{
	cout << "void func1(const T& x)" << endl;
}

//显示实例化函数模板
template
void func1<int>(const int& x);

template
void func1<double>(const double& x);  

//定义类模板成员函数
template<class T>   
AA<T>::AA()
	: _a(0)
	, _b(0)
{
	cout << "AA<T>" << endl;
}

//单独对类模板的某个成员函数显示实例化
template
AA<int>::AA();   

//显示实例化整个类
template
class AA<int>;

方法2：模板的声明和定义放在同一个.cpp/.h文件下 -- 大部分情况下使用的方法

在头文件展开后，直接就有函数或类模板的声明和定义，在使用时，可以直接找到对应的地址，而不需要通过链接去寻找。

演示代码3.2：（模板的定义和声明不分离）

//func.h文件 -- 声明和定义函数模板即类模板
template <class T>
void func1(const T& x);  //函数模板的声明

template<class T>
class AA   //类模板的声明
{
public:
	AA();
};

template <class T>
void func1(const T& x)   //函数模板的定义
{
	cout << "void func1(const T& x)" << endl;
}

template<class T>
AA<T>::AA()   //类模板构造函数的定义
{
	cout << "AA<T>" << endl;
}