C++ 【模版进阶】模版分离编译 模版特化

非类型模板参数

模板参数分类类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参:就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

//#define N 100

// 非类型模板参数 -- 整形常量
template<class T, size_t N = 10>
class MyStack
{
public:
	void Push(const T& x)
	{}
private:
	T _a[N];
	size_t _top;
};

//C++98 C++11
//template
template<size_t N>
class A
{};

int main()
{
	MyStack<int, 100> st1; // 100;
	MyStack<int, 200> st2; // 200;
	MyStack<int> st3;
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

如果我们要控制数组栈的大小，我们可以定义宏，但是宏不够灵活缺点还很多，这时候就可以使用非类型模版参数来代替。

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

类模板的特化

函数模板特化

函数模板的特化步骤：
1 . 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

 //函数模板 -- 参数匹配
template<class T>
bool ObjLess(T left, T right)
{
	return left < right;
}

// 函数模板里面。这种特化佷鸡肋
template<>
bool ObjLess<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

int main()
{
	cout << ObjLess(1, 2) << endl;
	Date* p1 = new Date(2022, 3, 26);
	Date* p2 = new Date(2022, 4, 26);

	// 参数匹配
	// 如果没有特化，那么将和模版匹配
	cout << ObjLess(p1, p2) << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

bool ObjLess(Date* left, Date* right)
{
	return *left < *right;
}

1
2
3
4
5

类模板特化

全特化

全特化即是将模板参数列表中所有的参数都确定化。

template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

// 特化 -- 特殊化，比如需要针对某些类型特殊化处理
template<>
class Data < int, char >
{
public:
	Data() { cout << "Data" << endl; }
private:
	int _d1;
	char _d2;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

全特化的应用场景

template<class T>
struct Less
{
	bool operator()(const T& x, const T& y) const
	{
		return x < y;
	}
};

1
2
3
4
5
6
7
8
9

Less仿函数实例化Date*数据类型比较方式不是我们想要的那么我们可以自己实现仿函数，按照自己想要的方式去比较，控制比较逻辑。

struct LessPDate
{
	bool operator()(const Date* d1, const Date* d2) const
	{
		//return *d1 < *d2;
		return (d1->_year < d2->_year) ||
			(d1->_year == d2->_year && d1->_month < d2->_month) ||
			(d1->_year == d2->_year && d1->_month == d2->_month && d1->_day < d2->_day);
	}
};
1
2
3
4
5
6
7
8
9
10

这种方式不是不行，而是不是泛型了，类名改了。

那么现在我们就可以通过特化来实现。

// 特化
template<>
struct Less<Date*>
{
	bool operator()(Date* x,Date* y) const
	{
		return *x < *y;
	}
};

1
2
3
4
5
6
7
8
9
10

偏特化

偏特化:任何针对模版参数进一步进行条件限制设计的特化版本。
比如对于以下模板类：

template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data" << endl; }
private:
	T1 _d1;
	T2 _d2;
};
1
2
3
4
5
6
7
8
9

偏特化有以下两种表现方式：

部分特化:
将模板参数类表中的一部分参数特化。

template<class T1>
class Data < T1, char >
{
public:
	Data() { cout << "Data" << endl; }
private:
};
1
2
3
4
5
6
7

参数更进一步的限制：
偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。如下对任意类型参数更进一步限制，只能是任意类型的指针或者引用。

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

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

// 
template<class T2>
class Data <char, T2& >
{
public:
	Data() { cout << "Data" << endl; }
private:
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

非类型模版参数也可以特化

template<size_t N>
class A
{
public:
	A(){ cout << "A" << endl; }
};

template<>
class A<10>
{
public:
	A(){ cout << "A<10>" << endl; }

};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

int main()
{
	Data<int, int> d1;// Data
	Data<int, char> d2;//Data

	Data<char, char> d3;//Data
	Data<double, char> d4;//Data

	Data<double*, char*> d5;//Data
	Data<char*, char*> d6;//Data

	Data<char&, char&> d7;//Data

	Data<char, int&> d8;// Data

	A<100> aa1;//A
	A<10> aa2;//A<10>
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

模板分离编译

什么是分离编译

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

模板的分离编译

在分离编译的情况下，需要.h文件放申明，.c/.cpp文件放定义，main.cpp放程序主执行逻辑代码。

代码分析：
程序运行起来前有4步要走：

1、预处理： 头文件展开、去注释、宏替换、条件编译等。
2、编译： 检查代码的规范性、是否有语法错误等，确定代码实际要做的工作，在检查无误后，将代码翻译成汇编语言。
3、汇编： 把编译阶段生成的文件转成目标文件。
4、链接： 将生成的各个目标文件进行链接，生成可执行文件。

前三步完成以后：
在Linux下就是生成了 sub.i , main.i目标文件。
这时候前三步都没什么问题，问题就再链接时sub(2,1)找不到被实例化的函数地址。说明该函数没有在sub.i被实例化。前面main.cpp文件没报错是因为我们有声明，虽然没有函数实体，但是加了声明就代表告诉编译器有实体只不过在需要通过链接器找，一种对编译器的承诺，现在没有函数实体也就报错了。

解决方案：
1、在sub.cpp中显示实例化int类型的模版函数。
这时候链接的时候就能找到了，不推荐这样写，需要手写显示实例化。

2、声明和定义不分离。
sub.h在main.cpp中展开，在编译时，编译器就会在main.cpp拿到模版来实例化一份函数处理，那么这时候sub(2,1)不需要在链接的时候去找函数，而是在编译时就把函数地址填上了。

模板总结

模版分离编译会存在链接不上的问题，有两种解决方案，推荐使用模版声明和定义不分离。

优点：
1、模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库（STL）因此而产生。
2、增强了代码的灵活性。

缺陷：

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