（C++）模板分离编译面对的问题

Posted 星空之下-

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了（C++）模板分离编译面对的问题相关的知识，希望对你有一定的参考价值。

什么是分离编译

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

模板的分离编译

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

//test.h
#include<iostream>
using namespace std;

//函数模板的声明
template<class T>
T Add(const T& left, const T& right);


//test.cpp
#include"test.h"
template<class T>

//函数模板的定义
T Add(const T& left, const T& right)

 return left + right;


//amin.cpp
#include"a.h"
int main()

 Add(1, 2);

 return 0;

如果模板进行分离编译会发现程序会出现链接错误，错误提示如下：
正常的函数进行分离编译不会有任何问题，而函数模板进行分离编译却会出现链接错误，这是为什么？

我们都知道一个程序要先经过编辑、编译、链接，才能运行，而上面的模板分离编译的链接错误，不就是链接阶段发生的吗？那让我们一起看看链接之前会发生什么。
我们将一个程序的代码编辑完之后，就会进入编译阶段，而编译阶段又可以细分为预处理、编译、汇编，看看它们分别发生了什么？
预处理：源文件中头文件的展开/宏替换/条件编译/去掉注释。

上面模板的分离编译中会将test.h在test.cpp和main.cpp中展开，那两个源文件中就都有了函数模板的声明，这一步是没有问题的。

编译：进行语法检查、生成汇编代码

在进行语法检查的时候，main.cpp中调用了模板函数，而在它调用之前已经有了函数模板的声明，说明语法没有问题，然后生成对应的汇编语言（要注意，调用函数肯定需要对应的函数地址，但现在只有函数的声明，那它的函数地址就是有待确定的）。而test.cpp中函数的定义在在这一阶段是需要被实例化的，但因为函数模板的模板参数无法确定类型，所以无法将函数模板实例化，也就无法生成对应的函数地址，那符号表中也就无法找到该函数的地址，但语法并没有问题（如果是普通函数，那就可以生成对应的函数地址）。

汇编：将汇编代码转换成机器码。其实只要上面的编译不检查出语法错误，那这一阶段就能进行。

经过以上阶段，就该进行链接了，前面main.cpp编译生成的汇编代码里待查的函数地址就要去符号表中找，但因为函数模板的定义并没有被实例化，符号表中并没有对应的函数地址，那main.cpp中调用的模板函数不就相当于找不到了吗，那就会报链接的错误。

那如何解决呢？
方法一：既然是因为编译阶段test.cpp中函数模板无法确定类型而无法实例化，那我们可以保持模板分离编译不表，然后在test.cpp中显示实例化。加上如下代码：

template
double Add<int>(const int& left,const int& right);

这样虽然解决当前的问题，但如果调用函数时类型变成了double类型，那又得显示实例化，这样太麻烦了。

方法二：如果函数模板的声明和定义要分离也要都放在一个文件中（比如上面就是放在test.h中），那这样编译阶段就函数模板的模板类型可以确定，也就可以生成对应的函数地址。链接时就不会出问题了。很明显方法二更好。

C++模板详解：泛型编程模板原理非类型模板参数模板特化分离编译

文章目录

1.泛型编程

如何实现一个通用的交换函数？

这点函数重载可以做到，比如一下Swap函数的重载，分别重载了俩种不同参数类型的Swap

void Swap(int& x, int& y)

	int tmp = x;
	x = y;
	y = tmp;


void Swap(char& x, char& y)

	char tmp = x;
	x = y;
	y = tmp;

但是这也带来了几点不好的地方：

1.重载的函数仅仅是类型不同，代码的复用率比较低，只要有新类型出现，就需要增加对应的函数

2.代码的可维护性比较低，一个出错可能所有的重载均出错

那么有什么好的解决方法吗？我们能否告诉编译器一个模子，让编译器根据不同类型利用该模子自己去生成相应的代码呢？

当然能，这就是泛型编程，即编写与类型无关的通用代码，这是代码复用的一种手段。而模板是泛型编程的基础。模板分为两种，函数模板和类模板。

2.函数模板

概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

函数模板的格式
template<typename T1, typename T2,......,typename Tn>

即：返回值类型 函数名(参数列表)

其中typename可以改成class（不能用struct）

例：

template <typename T>
void Swap(T& x, T& y)

	T tmp = x;
	x = y;
	y = tmp;

函数模板的原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数的实例化分为两种：隐式实例化和显式实例化。

隐式实例化

让编译器自己推演函数参数的类型。

需要注意的是隐式实例化的参数一定要匹配，否则可能产生分歧导致编译器无法识别。比如：

template<typename T>
T Add(const T& left, const T& right)

	return left + right;




int main()

	int a1 = 10, b1 = 20;
	double a2 = 10.0, b2 = 20.0;

	Add(a1, b2);

	return 0;

编译器报错，该语句不能通过编译,因为无法确定T是int还是double。

如何处理？有两种方式：

1.强制类型转换！但值得注意的是，强转会产生临时变量，临时变量是具有常性的，需要const修饰一下！

2.使用显式实例化

显式实例化

在函数名后的< >中指定模板参数的实际类型。

template<typename T>
T Add(const T& left, const T& right)

	return left + right;


int main()

	int a1 = 10, b1 = 20;
	double a2 = 10.0, b2 = 20.0;

	cout<<Add<int>(a1, b2)<<endl;

	return 0;

模板参数的匹配原则

1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

2.对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

3.模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

  • 如果有定义出来的函数,且类型完全匹配调用时实参类型,则执行定义出来的函数.
  • 如果定义出来的函数,不符合,则执行模板推演.

这部分没啥难度，不再举例说明，总的来说，对于函数调用的优先级就是：完全匹配 >模板匹配 >转换匹配。

3.类模板

(1) 类模板的定义格式

template<class T1, class T2, ..., class Tn>
class 类模板名

 // 类内成员定义
;

注意：

类模板中函数放在类外进行定义时，需要加模板参数列表；

template <typename T>
class Stack

public:
	Stack(int capacity = 4)
		:_a(new T[capacity])
		,_top(0)
		,_capacity(capacity)
	
	~Stack()
	
		delete[] _a;
		_top = _capacity = 0;
	
	void Push(T x);
private:
	T* _a;
	int _top;
	int _capacity;
;


// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <typename T>
void Stack<T>::Push(T x)

	if (_top == _capacity)
	
		_capacity *= 2;
		T* tmp = (T*)realloc(_a, sizeof(int) * _capacity);
		if (tmp == nullptr)
		
			cout << "realloc fail" << endl;
			exit(-1);
		
		_a = tmp;
	
	_a[_top++] = x;

对于普通类，类名就是类型；对于类模板，类名不是类型，类型是Class < T >

(2) 类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟 < >，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

int main()

	// Stack只是类名，不是类型，Stack<int>才是类型
	Stack<int> s1;
	Stack<char> s2;
	return 0;

4.非类型模板参数

类型参数：就是在模板的参数列表中在class后面加上参数的类型名称。
非类型参数：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

注意两点：

1.浮点数、类对象以及字符串是不允许作为非类型模板参数的。
2.非类型的模板参数必须在编译期就能确认结果。

template<class T =int, size_t N = 10>
class array
	
		 private:
	 	 T _array[N];
		 size_t _size;

5.模板特化

（1）函数模板的特化

当针对某一情景或者某一类型，函数模板无法满足要求，模板需要有特殊的处理，这个时候就需要用到模板的特化。

比如咱们要比较两个字符串是否相同：

template<class T>
bool IsEqual(T str1, T str2)

	return str1 == str2;


int main()

	char str1[] = "hello";
	char str2[] = "hello";

	if (IsEqual(str1, str2))
		cout << "true";
	else
		cout << "false";

上述代码输出false， 不满足咱们的要求， 因为调用函数IsEqual()时传递过去的是两个char*类型，他们两个比较的不是字符串的内容，而是指针的地址，所以返回false。

此时模板特化派上用场了：如果要比较char*, 可以用strcmp来对这个情况进行特殊处理

template<>
bool IsEqual<char*>(char* str1, char* str2)

	return strcmp(str1, str2) == 0;

此时就返回true， 符合预期了。

函数模板的特化步骤：

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

（2）类模板的特化

类也是同理，如果需要有特殊情景也需要特化处理
以如下类举例(后边全特化、偏特化都针对它）：

template<class T1, class T2>
class test

public:
	test()
	
		cout << "test<T1, T2>" << endl;
	

private:
	T1 _x;
	T2 _y;
;

全特化

全特化即是将模板参数列表中所有的参数都确定化。
例如：
这里对test<int,double>版本特化

template<>
class test<int, double>

public:
	test()
	
		cout << "test<int, double>" << endl;
	

private:
	int _x;
	double _y;
;

int main()

	test<double, double> t1;
	test<int, double> t2;

偏特化

偏特化即是任何针对模版参数进一步进行条件限制设计的特化版本

偏特化有两种表现方式，一种是部分参数特化，一种是参数修饰特化

部分参数特化

这里对第二个参数特化，只要第二个参数是double就会调用对应特化版本

template<class T1>
class test<T1, double>

public:
	test()
	
		cout << "test<T1, double>" << endl;
	

private:
	T1 _x;
	double _y;
;
int main()

	test<double, double> t1;
	test<int, double> t2;

参数修饰特化

比如用指针或者引用来修饰类型，也可以进行特化

template<class T1, class T2>
class test<T1*, T2*>

public:
	test()
	
		cout << "test<T1*, T2*>" << endl;
	

private:
	T1* _x;
	T2* _y;
;

int main()

	test<int*, double*> t;

6.模板的分离编译

对于一个代码量比较多的项目，通常都会采用声明与定义分离的方法，比如在头文件进行声明，在源文件完成代码的实现，最后通过链接的方法链接成单一的可执行文件。但是C++的编译器却不支持模板的分离编译，一旦进行分离编译，就会出现链接错误。

问题分析

//头文件a.h
template<class T>
bool IsEqual(const T& str1, const T& str2);

-------------
//源文件a.cpp
template<class T>
bool IsEqual(const T& str1, const T& str2)

	return str1 == str2;

--------------
//test.c
#include<iostream>
#include"a.h"
using namespace std;

int main()

	cout << IsEqual(3, 5);

	cout << IsEqual('a', 'b');

这里看上去是没有问题的，但是涉及到了模板的实例化规则。

当主函数调用这个函数的时候他就会去头文件中找到函数的声明，再通过声明找到a.h中的实现。
但是对于模板却并不会这样，因为上一章说过，模板的实例化只会在其第一次使用的时候才会进行，例如这里IsEqual(3, 5),他就会去头文件中寻找，但是头文件中只有声明，没有定义，无法将其实例化。他又想通过找到a.cpp中的函数定义来进行实例化，但是遗憾的是，a.cpp中只有IsEqual(const T& str1, const T& str2)的定义，没有IsEqual(const int & str1, const int T& str2)，因为在a.cpp中并没有使用到该类型的实例，所以自然也不会为其实例化出来，这时test.cpp中就根本无法找到这个函数的实现，就导致了链接失败。

解决方法:

这个问题其实没有什么完美的解决方法

  1. 将声明和定义放到同一个头文件中。
  2. 类模板显式实例化。

以上是关于（C++）模板分离编译面对的问题的主要内容，如果未能解决你的问题，请参考以下文章

C++初阶：模板进阶非类型模板参数 | 模板的特化 | 模板分离编译

C++初阶：模板进阶非类型模板参数 | 模板的特化 | 模板分离编译

C++模板

[C/C++]详解C++中的模板

[C/C++]详解C++中的模板

C++初阶第十三篇—模板进阶（非类型模板参数+模板特化+模板的分离编译）