当前位置： 首页 > article >正文

【C++】模板进阶（非类型模板参数、类模板的特化和模板的分离编译）

article 2025/1/9 16:25:37

     之前我们讲解过模板初阶，没有阅读过的童鞋可以先去阅读之前的博文----->模板初阶

本章我们将针对模板进行进一步的讲解。

目录

（一）非类型模板参数

（二）模板的特化

（1）概念

（2）函数模板的特化

（3）类模板的特化

1、全特化

2、偏特化（半特化）

 3、模板特化的应用

（三）模板分离编译

（一）非类型模板参数

非类型模板参数的引入：

  我们见一组样例，定义一个静态的栈：

#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就是非类型模板参数，在类中可以当做常量来使用，N=20：20是给出一个缺省参数。（若用户给出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;
}

可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。

所以针对日期类指针这种特殊的成员变量的比较，我们引入了模板的特化：

在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。
对于上述日期类我们要给出他模板的特化：
这里有同学就要问了，一般情况下如果函数模板遇到不能处理或者处理有误的类型
，为了实现简单通常都是将该函数直接给出。然后用 函数重载即可。
所以我们不常用函数模板特化这种方法！

 什么时候该用特化呢？

其实模板特化中分为函数模板特化与类模板特化。我们下面分开讲解：

（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;
}

原因是：分离的话，模板实例化不出对应的函数，但是编译时可以通过的，因为声明中有模板的声明，最后符号表重定位的时候，找不到对应的函数模板调用的地址。

2、解决方法：
  • 1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。
  • 2. 模板定义的位置显式实例化。

补充：

  • 模板不支持声明和定义分别放到xxx.h和xxx.cpp中
  • 一般是要放到一个文件中。有些地方就会命名成
  • xxx.hpp，寓意就是头文件和定义实现内容合并一起.
  • 但是并不是必须是.hpp, .h也是可以的

解决方案1：在template.cpp中针对于要使用的模板类型显示实例化（指定类型）

 解决方案2：在不要分离到两个文件中。直接写在xxx.hpp或xxx.h中，也就是声明和定义不分离

这样就能将函数实例化出来，在编译的时候就能call这个函数的地址了，就不需要链接的时候去找了。

感谢阅读，助您学业有成！


http://www.kler.cn/a/7867.html

相关文章：

  • ArrayList和HashMap区别
  • Java-编写的一个生产者-消费者模式
  • 数据治理如何激活企业沉睡数据价值？
  • LabVIEW四旋翼飞行器姿态监测系统
  • pytest日志显示
  • 机器人手眼标定
  • asa(苹果Apple Search Ads平台)授权调用接口
  • 【设置应用程序图标-启动图片 Objective-C语言】
  • Vue：初识Vue
  • 数字化可视化大屏：创新与融合的未来
  • 02.数据结构之算法
  • 指针的详细运用介绍（高阶）
  • NIFI大数据进阶_Kafka使用相关说明_实际操作Kafka消费者处理器_来消费kafka数据---大数据之Nifi工作笔记0037
  • Vue3通透教程【九】父子组件通讯一目了然
  • 【从零开始学习 UVM】12.8、UVM RAL（续更） —— UVM RAL Model 实战项目（基于AXI总线的寄存器读写实例）
  • 从前M个字母中取N个的无重复排列 [2*+]
  • SQL VQ13 统计每天总刷题数
  • 基于价值认同的需求侧电能共享分布式交易策略（Matlab代码实现）
  • 大数据=SQL Boy,SQL Debug打破SQL Boy 的僵局
  • HTTP1.1、HTTP2和HTTP3是HTTP协议的三个版本——相同点和不同点
  • LinkedIn领英一、二、三度人脉分别代表什么意思？如何突破人脉限制开启领英社交化客户开发
  • 开心档之C++ 运算符
  • 【机器学习学习笔记】机器学习入门监督学习
  • Linux系统常用命令大全
  • 泡泡玛特“失速”，盲盒经济迎来拐点?
  • MySQL 查询常用操作(2) —— 条件查询 where