【c++】模板进阶

> 作者简介：დ旧言~，目前大二，现在学习Java，c，c++，Python等
> 座右铭：松树千年终是朽，槿花一日自为荣。

> 目标：了解非类型模板参数，熟练使用模板的特化。

> 毒鸡汤：你活得不快乐的原因是：既无法忍受目前的状态，又没能力改变这一切。

> 望小伙伴们点赞👍收藏✨加关注哟💕💕 

🌟前言  

早期我们学习了模板，只能说浅学，很多重要的知识点都没有讲解，今天我们来深度讲解模板。

⭐主体

学习模板的进阶我们按照下面的图解来学习：

🌙非类型模板参数

模板参数分为: 类型形参与非类型形参

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

类型形参：

// T: 类型模板参数，它是一个类型
template <class T> class A;

非类型形参：

// T: 类型模板参数，它是一个类型
// N: 非类型模板参数，它是一个常量
template <class T, size_t N = 10> class A;

实例举例：

#define N 10
template<class T> // 静态栈
class Stack {
private:
	T _a[N];
	size_t _top;
};

void test()
{
	Stack<int> st1; // 10
	Stack<int> st2; // 10
}

问题分析：

现在实现了一个静态栈，可以存 10 个数据，实例化的每个对象都可以存 10 个数据，如果我想要第一个对象 st1 存 100 个数据，第二个对象存 200 个数据，这种结构就非常的不好。

问题解决：

此时就需要用到非类型模板参数了

template<class T, size_t N> // 静态栈
class Stack {
private:
	T _a[N];
	size_t _top;
};

void test()
{
	Stack<int, 100> st1; // 100
	Stack<int, 200> st2; // 200
}

注意事项：

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

(因为模板是在编译阶段就要实例化的,而模板必须要知道实例化成的具体类型之后才能实例化,

因此非类型模板参数和类型模板参数一样,必须在编译阶段就能够确认实例化成的具体类型才可以,

否则编译阶段无法完成实例化,链接阶段就找不到实例化出的具体的类,进而发生链接错误)

🌙模板的特化

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板。

💫问题探讨

比如：交换两个元素

template<class T>
void Swap(T& x, T& y)
{
    T tmp(x); x = y; y = tmp;
}

void test()
{
    int x = 1, y = 2;
    Swap(x, y);

    vector<int> v1 = { 1, 2, 3, 4 };
    vector<int> v2 = { 10, 20, 30, 40 };
    Swap(v1, v2); // 深拷贝式交换，代价太大，效率低
}

解决方案一：函数的匹配原则，写一个专门针对 vector 类型对象交换的函数：推荐这种

// 函数匹配原则，专门针对 vector<int> 类型对象交换的函数 -- 推荐这种
void Swap(vector<int>& v1, vector<int>& v2)
{
    v1.swap(v2); // 只需要交换对象内部的几个指针即可
}

解决方案二：函数模板的特化，针对 vector 类型对象的交换进行特殊化处理：

// 函数模板的特化（针对某些具体类型进行特殊化处理） -- 最后还是要经过模板推演
template<>
void Swap<vector<int>>(vector<int>& v1, vector<int>& v2)
{
    v1.swap(v2);
}

问题拓展：

此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化分为：函数模板特化与类模板特化。

💫函数特化步骤

函数模板的特化步骤：

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

小试牛刀：

template<class T1, class T2>  // 基础函数模板
void add(T1& x, T2& y)
{
	cout << "void add(T1& x, T2& y)" << endl;
}

template<>
void add<int, char>(int& x, char& y)  // 函数模板的特化
{
	cout << "void add<int, char>" << endl;
}

void test()
{
	int a = 1, b = 2;
	add(a, b);   // 走基础函数模板

	int c = 1;
	char d = 'a';
	add(c, d); // 走特化的void add<int, char>版本
}

💫类模板特化步骤

类模板的特化步骤：

1. 必须要先有一个基础的类模板。
2. 关键字 template 后面接一对空的尖括号 <>
3. 类名后跟一对尖括号 <>，尖括号中指定需要特化的类型。

类模板的特化分为：全特化 和 偏特化。

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

template<class T1, class T2> // 基础类模板
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

// 类模板的全特化 -- 最后还是要经过模板推演
// 将所有参数都确定化
template<>
class Data<double, double>
{
public:
	Data() { cout << "Data<double, double>" << endl; }
private:
	double _d1;
	double _d2;
};

void test()
{
	Data<int, int> d1;       // 走基础类模板
	Data<double, double> d2; // 走特化的double版本
}

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

template<class T1, class T2> // 基础类模板
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

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

// 类模板的偏特化
// 将部分参数确定化
template<class T1>
class Data<T1, char>
{
public:
	Data() { cout << "Data<T, char>" << endl; }
private:
	T1 _d1;
	char _d2;
};

void test()
{
	Data<int, int> d1;  // 走基础类模板
	Data<int, char> d3; // 走特化版本
}

②参数更进一步的限制，针对模板参数更进一步的条件限制所设计出来的一个特化版本：

// 不一定式特化部分参数，而是对参数更进一步的限制
// 两个参数偏特化为指针类型
template<class T1, class T2>
class Data<T1*, T2*>
{
public:
	Data() { cout << "Data<T1*, T2*>" << endl; }
private:
	T1* _d1;
	T2* _d2;
};

// 两个参数偏特化为引用类型
template<class T1, class T2>
class Data<T1&, T2&>
{
public:
	Data(const T1& d1, const T2& d2)
		:_d1(d1)
		, _d2(d2)
	{
		cout << "Data<T1&, T2&>" << endl;
	}
private:
	const T1& _d1;
	const T2& _d2;
};

void test()
{
	Data<int, int> d1;         // 调用基础的类模板

	// 不管显示实例化什么类型的指针都可以
	Data<int*, char*> d4;      // 调用特化的指针版本
	Data<int*, int*> d5;       // 调用特化的指针版本

	// 不管显示实例化什么类型的引用都可以
	Data<int&, int&> d6(1, 2); // 调用特化的引用版本
}

💫匹配顺序

模板参数的匹配原则:

• 会优先匹配更匹配的
• 如果跟全特化匹配,就匹配全特化
• 否则如果跟偏特化更匹配,就匹配偏特化
• 如果跟偏特化也不匹配,就匹配原模板

🌙模板分离编译

💫概念

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

💫模板的分离编译

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

// func.h
template<class T>
T Add(const T& x, const T& y);

// func.cpp
#include"func.h"
template<class T>
T Add(const T& x, const T& y)
{
	return x + y;
}

// main.cpp
#include"func.h"
int main()
{
	Add(1, 2);
	Add(1.0, 2.0);
	return 0;
}

此段代码运行会报链接错误（链接错误一般是指在链接阶段找不到该函数的定义）

C/C++程序要运行，一般要经历一下步骤：预处理 --> 编译 --> 汇编 --> 链接

这里就不再讲解C++编译过程，具体可以参考这篇博客：Linux编辑器-gcc/g++使用-CSDN博客

优化设计：

• 不分离编译，将声明和定义放到一个文件 “xxx.h” 中，这样头文件展开后，main.cpp 中就有函数的定义，链接时就不需要去找函数的地址了，推荐使用这种。
• 在模板定义的位置显式指定实例化。用一个类型就得显式实例化一个类型，很麻烦，不实用，不推荐使用。

// func.h
template<class T>
T Add(const T& x, const T& y); // 函数模板的声明

// func.cpp
#include"func.h"
template<class T>
T Add(const T& x, const T& y) // 函数模板的实现
{
	return x + y;
}
template
int Add(const int& x, const int& y); // 显示实例化函数模板
template
double Add(const double& x, const double& y); // 显示实例化函数模板

// main.cpp
#include"func.h"
int main()
{
	Add(1, 2);     // call Add<int>
	Add(1.0, 2.0); // call Add<double>
	return 0;
}

🌙模板总结

优点：

1. 模板复用了代码，节省资源，可以更快的迭代开发，C++的标准模板库(STL)因此而产生。
2. 增强了代码的灵活性。

缺陷：

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

模板这个语法整体而言肯定是优点远大于缺点。

 🌟结束语

       今天内容就到这里啦，时间过得很快，大家沉下心来好好学习，会有一定的收获的，大家多多坚持，嘻嘻，成功路上注定孤独，因为坚持的人不多。那请大家举起自己的小手给博主一键三连，有你们的支持是我最大的动力💞💞💞，回见。