C++模板进阶（非类型模板参数类模板的特化和模板的分离编译）
Posted 朱C.
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++模板进阶（非类型模板参数类模板的特化和模板的分离编译）相关的知识，希望对你有一定的参考价值。
之前我们讲解过模板初阶，没有阅读过的童鞋可以先去阅读之前的博文----->模板初阶
本章我们将针对模板进行进一步的讲解。
目录
（一）非类型模板参数
非类型模板参数的引入：
我们见一组样例，定义一个静态的栈：
#define N 100
template<class T>
class Stack
private:
T _a[N];
int _pop;
;
这里有个缺陷，这里的栈的大小是固定死的，每次创建出来的栈都是一样的大小。
那么问题来了怎么可以创建不同大小的数组：
模板让我们实现了同时可以创建不同数据类型的栈，但是不能实现不同数据个数的栈。
这里就引入了非类型模板参数：
//N是非类型模板参数，在类中当做常量来使用
//只能是整型常量
template<class T,int N=20>
class Array//库中也有array，array读写全面检查，检查更细致，但一般还是用vector
public:
private:
T _a[N];
;- N是常量不能修改
- 模板不仅可以不定义类型，还可以定义常量
- 比宏更好，可以传一个常量过去，定义不同的对象，可以传不同的常量过去
- 1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
- 2. 非类型的模板参数必须在编译期就能确认结果。
- 类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
- 非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
（二）模板的特化
（1）概念
通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板。 我们用日期类举例：#include<iostream>
using namespace std;
class Date
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
bool operator<(const Date& d)const
return (_year < d._year) ||
(_year == d._year && _month < d._month) ||
(_year == d._year && _month == d._month && _day < d._day);
bool operator>(const Date& d)const
return (_year > d._year) ||
(_year == d._year && _month > d._month) ||
(_year == d._year && _month == d._month && _day > d._day);
friend ostream& operator<<(ostream& _cout, const Date& d)
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
private:
int _year;
int _month;
int _day;
;
// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
return left < right;
我们给出下面几种比较方式：
int main()
cout << Less(1, 2) << endl; // 可以比较，结果正确
Date d1(2022, 7, 7);
Date d2(2022, 7, 8);
cout << Less(d1, d2) << endl; // 可以比较，结果正确
Date* p1 = &d1;
Date* p2 = &d2;
cout << Less(p1, p2) << endl; // 可以比较，结果错误（没有函数模板特化前）
return 0;
所以针对日期类指针这种特殊的成员变量的比较，我们引入了模板的特化：
在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。 对于上述日期类我们要给出他模板的特化：
这里有同学就要问了，一般情况下如果函数模板遇到不能处理或者处理有误的类型
，为了实现简单通常都是将该函数直接给出。然后用 函数重载即可。 所以我们不常用函数模板特化这种方法！
什么时候该用特化呢？
其实模板特化中分为函数模板特化与类模板特化。我们下面分开讲解：
（2）函数模板的特化
函数模板的 特化步骤：- 1. 必须要先有一个基础的函数模板
- 2. 关键字template后面接一对空的尖括号<>
- 3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
- 4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
return left < right;
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
return *left < *right;
int main()
cout << Less(1, 2) << endl;
Date d1(2022, 7, 7);
Date d2(2022, 7, 8);
cout << Less(d1, d2) << endl;
Date* p1 = &d1;
Date* p2 = &d2;
cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了
return 0;
该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时特别给 出，因此像之前提到的一样：函数模板不建议特化。
（3）类模板的特化
既然上面函数模板的特化不建议使用，那么类模板的特化必将有大作用。
1、全特化
全特化即是将模板参数列表中所有的参数都确定化template<class T1, class T2>
class Data
public:
Data() cout << "Data<T1, T2>" << endl;
private:
T1 _d1;
T2 _d2;
;
//类模板的特化 -- 全特化（写死了）
template<>
class Data<int, double>
public:
Data() cout << "Data<int, double>" << endl;
;
- 制定好了两个模板参数 —— 写死了
- 只能固定的类型走这个函数
- 例如：只能是int 和 double走全特化的模板
2、偏特化（半特化）
偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。 偏特化有以下两种表现方式： 部分特化 将模板参数类表中的一部分参数特化 参数更进一步的限制 偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。 比如对于以下模板类：//半特化 / 偏特化（）半特化不是特化一半
//1、将部分模板参数列表中的一部分参数特化
template<class T1>
class Data<T1, char>
public:
Data() cout << "Data<T1, char>" << endl;
;
//2、偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本
//只要T1 和 T2是指针就走这个 -- 针对指针特殊化处理
template<class T1, class T2>
class Data<T1*, T2*>
public:
Data() cout << "Data<T1*, T2*>" << endl;
;
template<class T1, class T2>
class Data<T1&, T2&>
public:
Data() cout << "Data<T1&, T2&>" << endl;
;
int main()
Data<int, int> d1;
Data<int, double> d2;
//只要第二个是char都会匹配：半特化/偏特化
Data<int, char> d3;
Data<char, char> d4;
//只要是两个指针
Data<int*, int*> d5;
Data<int*, char*> d6;
Data<int*, string*> d7;
Data<int*, void*> d8;
//void不是类型，但是void*是一个类型，void*是不能解引用不能++
Data<int*, int> d9;//匹配原生的指针
Data<int&, char&> d10;
return 0;
//也可以写成typename
//template <typename T1, typename T2>
//class Data <T1*, T2*>
//
//public:
// Data() cout << "Data<T1*, T2*>" << endl;
//
//private:
// T1 _d1;
// T2 _d2;
//;
//
//template <typename T1, typename T2>
//class Data <T1&, T2&>
//
//public:
// Data(const T1& d1 = T1(), const T2& d2 = T2())
// : _d1(d1)
// , _d2(d2)
//
// cout << "Data<T1&, T2&>" << endl;
//
//
//private:
// const T1& _d1;
// const T2& _d2;
//;
//
//template <typename T1, typename T2>
//class Data <T1&, T2*>
//
//public:
// Data(const T1& d1 = T1())
//
//
// cout << "Data<T1&, T2*>" << endl;
//
//;
//int main()
//
// Data<int, int> d1;
// Data<int*, char*> d2;
// Data<int*, int> d3;
// Data<double, int> d4;
//
// Data<int*, int*> d5;
//
// Data<int&, char&> d6;
// Data<int&, char*> d7;
//
// return 0;
//
//运行结果如下：
3、模板特化的应用
有如下专门用来按照小于比较的类模板Less：//模板的特化 -- 应用
template<class T>
struct Less
bool operator()(const T& x, const T& y) const
return x < y;
;
template<>
struct Less<Date*>
bool operator()(Date* x, Date* y) const
return *x < *y;
;
//偏特化
//只要是指针都走这里
template<class T>
struct Less<T*>
bool operator()(T* x, T* y) const
return *x < *y;
;
int main()
Date d1(2022, 7, 7);
Date d2(2022, 7, 6);
Date d3(2022, 7, 8);
vector<Date> v1;
v1.push_back(d1);
v1.push_back(d2);
v1.push_back(d3);
// 可以直接排序，结果是日期升序
sort(v1.begin(), v1.end(), Less<Date>());
vector<Date*> v2;
v2.push_back(&d1);
v2.push_back(&d2);
v2.push_back(&d3);
//可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序
//此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象
//但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期
sort(v2.begin(), v2.end(), Less<Date*>());
vector<int*> v3;
v3.push_back(new int(3));
v3.push_back(new int(1));
v3.push_back(new int(2));
sort(v3.begin(), v3.end(), Less<int*>());
return 0;
（三）模板分离编译
1、 什么是分离编译 一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。 假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：// a.h
template<class T>
T Add(const T& left, const T& right);
// a.cpp
template<class T>
T Add(const T& left, const T& right)
return left + right;
// main.cpp
#include"a.h"
int main()
Add(1, 2);
Add(1.0, 2.0);
return 0;
原因是：分离的话，模板实例化不出对应的函数，但是编译时可以通过的，因为声明中有模板的声明，最后符号表重定位的时候，找不到对应的函数模板调用的地址。
- 1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。
- 2. 模板定义的位置显式实例化。
补充：
- 模板不支持声明和定义分别放到xxx.h和xxx.cpp中
- 一般是要放到一个文件中。有些地方就会命名成
- xxx.hpp，寓意就是头文件和定义实现内容合并一起.
- 但是并不是必须是.hpp, .h也是可以的
解决方案1：在template.cpp中针对于要使用的模板类型显示实例化（指定类型）
解决方案2：在不要分离到两个文件中。直接写在xxx.hpp或xxx.h中，也就是声明和定义不分离
这样就能将函数实例化出来，在编译的时候就能call这个函数的地址了，就不需要链接的时候去找了。
感谢阅读，助您学业有成！
C++模板进阶
模板进阶
目标
非类型模板参数
类模板的特化
类模板特化的应用之类型萃取
模板的分离编译
非类型模板参数
模板参数分类类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用
注意：
1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
2. 非类型的模板参数必须在编译期就能确认结果
模板的特化
概念
通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果
这时候就需要对模板进行特化，即在原模板的基础上，针对特殊类型所进行特殊化的实现方式，模板特化中分为函数模板特化与类模板特化
模板的编译
函数模板的特化
函数模板特化步骤：
1.必须先有一个基础的函数模板
2.关键字template后面接一对空的尖括号
3.函数名后跟一对尖括号，尖括号中指定需要特化的类型
4.函数形参列表：必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误
由于编译器可以自动推演，选择最合适的函数接口，即有适合的函数，就会直接调用，而不会再去进行推演因此函数模板特化的时候，可以写成不严谨形式的特化
非严谨形式的特化
template<class T>
int compare( T& a, T& b)
{
cout << "template<T>调用" << endl;
return a > b;
}
//非严谨的函数模板化
int compare( char* str1, char* str2)
{
return strcmp(str1,str2);
}
int main()
{
char str1[] = "hello";
char str2[] = "world";
int ret = compare(str1, str2);
if (ret > 0)
{
cout << "str1>str2" << endl;
}
else
{
cout << "str1<=str2" << endl;
}
}
严谨的函数模板特化
template<class T>
int compare(T a, T b)
{
cout << "template<T>调用" << endl;
return a > b;
}
//严谨的函数模板化
template<>
int compare<char*>(char* left, char* right)
{
if (strcmp(left, right) > 0)
return 1;
else if (strcmp(left, right) == 0)
{
return 0;
}
else
{
return -1;
}
}
int main()
{
char str1[] = "hello";
char str2[] = "world";
int ret = compare(str1, str2);
if (ret > 0)
{
cout << "str1>str2" << endl;
}
else
{
cout << "str1<=str2" << endl;
}
}
类模板化
全特化
将模板参数列表中所有的参数都确定化
template<class T1, class T2>
class Data
{
public:
Data()
{
cout << "Data<T1, T2>" << endl;
}
private:
T1 _d1;
T2 _d2;
};
// 类模板的特化方式一：全特化
template<>
class Data<int, double>
{
public:
Data()
{
cout << "Data<int, double>" << endl;
}
private:
int _d1;
double _d2;
};
int main()
{
Data<int, int> d1;
Data<double, double> d2;
Data<int, double> d3;
Data<double, int> d4;
return 0;
}
偏特化–重点
偏特化方式一、部分特化
template<class T1, class T2>
class Data
{
public:
Data()
{
cout << "Data<T1, T2>" << endl;
}
private:
T1 _d1;
T2 _d2;
};
// 偏特化方式一：部分特化
// 将来对Data类模板进行实例化时，第二个参数如果是int类型的，都走特化版本
template<class T1>
class Data<T1, int>
{
public:
Data()
{
cout << "Data<T1, int>" << endl;
}
private:
T1 _d1;
int _d2;
};
// 偏特化方式二：对参数类型更详细的限制
// 说明：在对Data实例化时，只要两个参数类型都是指针参数，就使用特化版本
// 否则就使用类模板
template<class T1, class T2>
class Data<T1*, T2*>
{
public:
Data()
{
cout << "Data<T1*, T2*>" << endl;
}
private:
T1* _d1;
T2* _d2;
};
模板分离编译
什么是分离编译
一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式
模板分离所带来的优点
1.提高效率
2.方便管理和阅读代码
如上图所示，一个整体的文件，里面充满了内容，没有分出模块，阅读起来和管理起来都是比较麻烦的
当文件分为一个个小模块之后，阅读感更好，管理也比较方便
普通.h文件实例化模板所造成问题
解决方法
首先介绍一下.hpp与.h区别
hpp，其实质就是将.cpp的实现代码混入.h头文件当中，定义与实现都包含在同一文件，则该类的调用者只需要include该hpp文件即可，无需再将cpp加入到project中进行编译。而实现代码将直接编译到调用者的obj文件中，不再生成单独的obj，采用hpp将大幅度减少调用 project中的cpp文件数与编译次数，也不用再发布烦人的lib与dll，因此非常适合用来编写公用的开源库。
链接
解决方案–将头文件由.hpp替换掉.h
#pragma once
template<class T>
T ADD(T a, T b)
{
return a + b;
}
#include"template.hpp"
int main()
{
cout << ADD(1, 2) << endl;
cout << ADD(2.0, 10.0) << endl;
}
模板优缺点
优点】
- 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
- 增强了代码的灵活性
【缺陷】
- 模板会导致代码膨胀问题，也会导致编译时间变长
- 出现模板编译错误时，错误信息非常凌乱，不易定位错误
以上是关于C++模板进阶（非类型模板参数类模板的特化和模板的分离编译）的主要内容，如果未能解决你的问题，请参考以下文章