C++学习之深入学习模板（进阶）
在C++前面的学习中，我们初步了解到了C++中模板的使用和类型。本次我们将进一步深入学习C++的模板。
C++模板初阶内容博客：C++学习之模板初阶学习-CSDN博客
前面我们学习的模板是类型模板参数的模板，接下来我们将学习非类型模板参数
作者的个人gitee：楼田莉子 (riko-lou-tian) - Gitee.com喜欢可以支持一下。
目录
非类型模板参数
模板的特化
概念
函数模板特化
这里额外补充一个以往的知识：const修饰
类模板特化
全特化
偏特化
模板的分离期编译
什么是分离期编译
模板的分离编译
模板总结
非类型模板参数
模板参数分类类型形参与非类型形参。
类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
类型模板参数
#include <iostream>
using namespace std;
//类型模板参数
//静态的模板
#define N 100;
template<class T>
class stack
{private:T _a[N];int _top;int _capacity;
};
int main()
{stack<int> s1; //初始化为10stack<int> s2; //初始化为1000return 0;
}它是静态的，当我们要初始化两个的时候就非常麻烦。
非类型模板参数
//非类型模板参数
template<class T, size_t N>
class stack
{
private:T _a[N];int _top;int _capacity;
};
int main()
{stack<int, 10>s1; //初始化为10stack<int, 1000>s2; //初始化为1000return 0;
}但是这么玩是比较危险的。因为栈的内存是不大的，在Linux的进程下栈只有8M。
//非类型模板参数
template<class T, size_t N>
class stack
{
private:T _a[N];int _top;int _capacity;
};
int main()
{stack<int, 10>s1; //初始化为10stack<int, 1000>s2; //初始化为1000cout<<sizeof(s1)<<endl; //输出10*4=40cout<<sizeof(s2)<<endl; //输出1000*4=4000return 0;
}在上述代码的结果为：
如果继续扩大，那么就会报错“栈溢出”
所以我们调用大对象或者递归调用过深就会有危险。
但是模板只能传递常量，不能传递变量：
和之前一样，非类型模板参数也可以传递缺省值，
//非类型模板参数
template<class T=int , size_t N=100 >
class stack
{
private:T _a[N];int _top;int _capacity;
};
int main()
{stack<int, 10>s1; //初始化为10stack<int, 1000>s2; //初始化为1000stack<>s3; //默认初始化为100return 0;
}但是浮点数不能作为缺省值（C++20 才开始用浮点类型的数据作为缺省值）
C++14版本（VS2022最低支持版本为14）
//非类型模板参数
//当前版本为C++14的情况下不支持浮点数作为缺省值
template<class T=int , double N=100 >
class stack
{
private:T _a[N];int _top;int _capacity;
};
int main()
{stack<int, 10>s1; //初始化为10stack<int, 1000>s2; //初始化为1000stack<>s3; //默认初始化为100return 0;
}
C++ 20版本
//非类型模板参数
//当前版本为C++20的情况下不支持浮点数作为缺省值
template<class T, double N = 100.0>
class stack
{
private:T _a[N];int _top;int _capacity;
};
int main()
{stack<int, 2.0>s1; stack<int, 1.0>s2; return 0;
}非类型模板参数在编译期才能确定成果
非类型模板参数的应用：STL的设计
典型的就是STL之array：数组 - C++ 参考
和STL的bitset（哈希相关的时候很重要）：位集 - C++ 参考
array的越界检查相较于C语言的静态数组，只要越界写一定会报错；但是array不阻止越界读。
模板的特化
概念
通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理。
函数模板特化
函数模板的特化步骤：
1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
比如我们实现一个小于比较的函数
//函数模板的特化
template<class T>
bool Less(T a, T b)
{return a < b;
}
int main()
{cout<<Less(1, 2)<<endl; return 0;
}但是在这样的场景下就不一定成立
//函数模板的特化
template<class T>
bool Less(T a, T b)
{return a < b;
}
int main()
{cout<<Less(1, 2)<<endl; double* p1 = new double(2.2);double* p2 = new double(1.1);cout<<Less(p1, p2)<<endl;return 0;
}（每一次结果都不一定一样）
可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。
此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。
同时这里我们要对上面的代码进行修正，比较小于的函数不应该传值传参。这样面对自定义类型(如string、vector)会进行深拷贝，开销特别大，正确的写法应该是
//函数模板的特化template<class T>
bool Less(const T& a,const T& b)
{return a < b;
}但是这样特化的难度又会特别大。
这里额外补充一个以往的知识：const修饰
//const 修饰的是*p1
const T* p1;
//const 修饰的是*p2
T const * p2;
//const 修饰的是p3
T* const p3;const在*左边修饰指向对象不能修改；const在*右边修饰的是指针本身
正确的特化：
//函数模板的特化
template<class T>
bool Less(const T& a,const T& b)
{return a < b;
}
//进行特化
template<>
// const在*左边修饰指向对象不能修改；
// const在*右边修饰的是指针本身
bool Less<double*>( double*const& a, double*const & b)
{return *a < *b;
}
int main()
{cout<<Less(1, 2)<<endl; double* p1 = new double(2.2);double* p2 = new double(1.1);cout<<Less(p1, p2)<<endl;return 0;
}类模板特化
模板特化有两种：全特化和偏特化。下面分别来介绍
全特化
//类模板的特化
template<class T1,class T2>
class Date
{
public:Date(){cout<<"Date<T a,T b>"<<endl;}
private:T1 _a;T2 _b;
};
//全特化
template<>//全特化必须要加
class Date<int,char>
{
public:Date(){cout << "Date<int,char>" << endl;}
};
int main()
{Date<int, int> d1;Date<int, char> d2;return 0;
}结果为：
偏特化
//类模板的特化
template<class T1,class T2>
class Date
{
public:Date(){cout<<"Date<T a,T b>"<<endl;}
private:T1 _a;T2 _b;
};
//全特化
template<>//全特化必须要加
class Date<int,char>
{
public:Date(){cout << "Date<int,char>" << endl;}
};
//偏特化
//特化部分参数
template<class T1>//全特化必须要加
class Date<T1, char>
{
public:Date(){cout << "Date<T1, char>" << endl;}
};
int main()
{Date<int, int> d1;Date<int, char> d2;//全特化和偏特化均可，但是更倾向于匹配全特化Date<char, char> d3;//偏特化return 0;
}类模板特化的本质是新建一个类。下面通过实验证明
//类模板的特化
template<class T1,class T2>
class Date
{
public:Date(){cout<<"Date<T a,T b>"<<endl;}void F1();
private:T1 _a;T2 _b;
};
//全特化
template<>//全特化必须要加
class Date<int,char>
{
public:Date(){cout << "Date<int,char>" << endl;}
};
//偏特化
//特化部分参数
template<class T1>//全特化必须要加
class Date<T1, char>
{
public:Date(){cout << "Date<T1, char>" << endl;}
};
int main()
{Date<int, int> d1;d1.F1();//调用模板的F1()函数，没有报错Date<int, char> d2;//全特化和偏特化均可，但是更倾向于匹配全特化d2.F1();//特化的类没有F1()函数，报错Date<char, char> d3;//偏特化return 0;
}如果我们对参数进行进一步地限制
//对参数进一步限制
template<class T1,class T2>
class Date<T1*, T2*>//是任何类型的指针都会匹配
{public:Date(){cout << "Date<T1*, T2*>" << endl;}
};
int main()
{Date<int*,int*>d4;Date<char*, char*>d5;Date<int*, char*> d6;return 0;
}结果为：
特化不仅可以限制指针还能限制引用
模板的分离期编译
什么是分离期编译
一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。
模板的分离编译
当我们声明与定义不分离的时候
func.h
#pragma once
#include<iostream>
using namespace std;
template<class T>
void FuncT(const T& x)
{cout<<"FuncT(const T& x)"<<endl;
}
test.cpp
#define _CRT_SECURE_NO_WARNINGS
#include "func.h"
int main()
{FuncT(1);return 0;
}结果为：
但是当我们声明与定义分离的时候就会出问题。因为默认情况下我们很难
func.cpp
#define _CRT_SECURE_NO_WARNINGS
#include"func.h"
void FuncT(const T& x)
{cout << "FuncT(const T& x)" << endl;
}func.h
#pragma once
#include<iostream>
using namespace std;
template<class T>
void FuncT(const T& t);结果为：
为什么呢？让我们来解析以下：
1、 编译器在编译的时候先预处理（展开头文件，宏替换，条件编译）
所以func.h中的头文件会分别在test.cpp和func.cpp中被展开
就像这样
#pragma once
#include<iostream>
using namespace std;
template<class T>
void FuncT(const T& t);#define _CRT_SECURE_NO_WARNINGS
#include "func.h"
int main()
{FuncT(1);return 0;
}2、编译：检查语法问题，如果没问题就生成汇编代码
3、汇编：生成二进制机器码
4、合并链接：生成可执行程序、
但是我们知道，如果我们在.h文件里声明普通函数没有定义是不行的。那为什么模板函数不行呢？
如果我们在func.cpp文件里显式实例化的话就能正常运行
func.h
#pragma once
#include<iostream>
using namespace std;
template<class T>
void FuncT(const T& t);func.cpp
#define _CRT_SECURE_NO_WARNINGS
#include"func.h"
template<class T>
void FuncT(const T& x)
{cout << "FuncT(const T& x)" << endl;
}
//显式实例化
template
void FuncT<int>(const int& x);test.cpp
#define _CRT_SECURE_NO_WARNINGS
#include "func.h"
int main()
{FuncT(1);return 0;
}结果如下：
理论上模板不是不可以声明与定义分离，但是在实际操作过程中，这样做很麻烦，而且出错的情况也会很多很麻烦。所以实际情况下尽量不要让模板的声明与定义分离
链接不上的原因是func.cpp那边没有实例化的模板，链接的找不到地址。
解决方法：
1、在.cpp文件中显式实例化
但是实际应用中很麻烦，不推荐使用
2、直接定义在.h文件中。
定义在.h文件中使用模板的地方直接包含了定义，编译的时候实例化生成了函数的地址，不需要链接。
扩展内容可以看这个文章：http://blog.csdn.net/pongba/article/details/19130
类模板与之类似
模板总结
【优点】
1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
2. 增强了代码的灵活性
【缺陷】
1. 模板会导致代码膨胀问题，也会导致编译时间变长
2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误
本期内容就到这里，喜欢请点一个赞，谢谢
封面图自取：
