模版进阶（沉淀中）

懒羊羊大王&2025-04-04 15:20

文章目录

  • 模板
    • [1. 非类型模板参数](#1. 非类型模板参数)
        • [扩展 std::array](#扩展 std::array)
    • [2. 模板的特化](#2. 模板的特化)
      • [2.1 概念](#2.1 概念)
      • [2.2 函数模板特化](#2.2 函数模板特化)
      • [2.3 类模板特化](#2.3 类模板特化)
        • [2.3.1 全特化](#2.3.1 全特化)
        • [2.3.2 偏特化](#2.3.2 偏特化)
        • [2.3.3 类模板特化应用示例](#2.3.3 类模板特化应用示例)
    • [3 模板分离编译](#3 模板分离编译)
      • [3.1 什么是分离编译](#3.1 什么是分离编译)
      • [3.2 模板的分离编译](#3.2 模板的分离编译)
      • [3.3 解决方法](#3.3 解决方法)
    • [4. 模板总结](#4. 模板总结)
  • 总结

模板

1. 非类型模板参数

模板参数分类类型形参与非类型形参。
类型形参 即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参 ，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
非类型形参应用和与宏的对比：
宏不能加分号，这里写死只能定义一个

cpp 复制代码 
#include<iostream>
using namespace std;
//#define N 20     //宏不能加分号，这里写死只能定义一个
//非类型模版参数
//只支持整型
template<class T,size_t N =10>
class Stack
{
private:
	T _a[N];
	int _top;
};
//c++20以后才支持浮点类型
//template<class T, double N = 10.1>  
//class Array
//{
//private:
//	T _a[N];
//	int _top;
//};
int main()
{
	//Stack<int> st1;

	Stack<int> st0;//10
	Stack<int,20> st1;//20
	Stack<int,2000> st2;//2000
	return 0;
}
扩展 std::array
cpp 复制代码 
#include<array>
#include<vector>

int main()
{
	//Stack<int> st1;

	Stack<int> st0;//10
	Stack<int,20> st1;//20
	Stack<int,2000> st2;//2000

	array<int, 100> a1;
	array<int, 200> a2;
	int aa1[100];
	int aa2[200];
	//cout << aa1[105] << endl;//越界检查不出
	//cout << a1[105] << endl; //限制了size可以检查出越界
	//vector 更好用
	vector<int> v1(100, 1);

	return 0;
}

cout << a1[105] << endl; //限制了size可以检查出越界

2. 模板的特化

2.1 概念

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

2.2 函数模板特化

函数模板的特化步骤：

  1. 必须要先有一个基础的函数模板
  2. 关键字template后面接一对空的尖括号<>
  3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
  4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
cpp 复制代码 
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);
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}


// 函数模板的特化 -- 参数匹配
#include"Queue.h"
template<class T>
bool Less(T left, T right)
{
	return left < right;
}
//特化模版，要排在默认的后面，不然走不通
//特化（对Date*特殊化处理）
template<>//注意：要特化模版参数为空
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

//用函数重载取代替特化
//bool Less(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;

	Date* p1 = new Date(2025, 2, 2);
	Date* p2 = new Date(2025, 4,2);
	cout << Less(p1, p2) << endl; // 可以比较，结果错误(随机)；有特化模版走特化（结果正确），没特化模版走默认
	return 0;
}

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

cpp 复制代码 
//用函数重载取代替特化
bool Less(Date* left, Date* right)
{
	return *left < *right;
}

2.3 类模板特化

2.3.1 全特化

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

cpp 复制代码 
template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};
//全特化
template<>
class Data<int, char>
{
public:
	Data() { cout << "Data<int, char>" << endl; }
private:
	int _d1;
	char _d2;
};
int main()
{
	Data<int, int> d1;
	Data<int, char> d2;
	return 0;
}
2.3.2 偏特化

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

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

(1)部分特化

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

(2)参数更进一步的限制

偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

cpp 复制代码 
template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};
//全特化
template<>
class Data<int, char>
{
public:
	Data() { cout << "Data<int, char>" << endl; }
private:
	int _d1;
	char _d2;
};
//偏特化---特化部分参数
template <class T1>
class Data<T1, int>
{
public:
	Data() { cout << "Data<T1, int>" << endl; }
private:
	T1 _d1;
	int _d2;
};

//参数更进一步的限制
//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
	Data() { cout << "Data<T1*, T2*>" << endl; }
private:
};

//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:
	Data()//不能加参数会报错
	{
		cout << "Data<T1&, T2&>" << endl;
	}
private:
	
};

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

};

template <typename T1, typename T2>
class Data <T1&, T2*>
{
public:
	Data()
	{
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;

		cout << "Data<T1&, T2*>" << endl;
	}
private:
};
int main()
{
	Data<int, int> d1;
	Data<int, char> d2;
	Data<char, char> d3;
	Data< char, int> d4;
	Data< char*, int*> d5;
	Data< char*, int&> d6;
	Data< char&, int*> d7;
	return 0;
}
2.3.3 类模板特化应用示例
cpp 复制代码 
#include<vector>
#include<algorithm>
template<class T>
struct Less
{
	bool operator()(const T& x, const 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*>());
	return 0;
}

通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排序元素是指针，结果就不一定正确。因为：sort最终按照Less模板中方式比较，所以只会比较指针，而不是比较指针指向空间中内容，此时可以使用类版本特化来处理上述问题：

cpp 复制代码 
// 对Less类模板按照指针方式特化
template<>
struct Less<Date*>
{
bool operator()(Date* x, Date* y) const
{
return *x < *y;
}
};

3 模板分离编译

3.1 什么是分离编译

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

3.2 模板的分离编译

分析：链接时，Func可以链接成功，Add无法链接成功

why？
test.i中知道Add需要实例化成int和double各一份Add函数，但是他只有声明没有定义。
a.i中知道有Add的定义，但是不知道实例化成类型。

a.h

cpp 复制代码 
#pragma once
#include<iostream>
using namespace std;
//函数模版
template<class T>
T Add(const T& left, const T& right);


void Func(int x);

a.cpp

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include"a.h"

//template<class T>
//T Add(const T& left, const T& right);
//
//
//void Func(int x);
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

void Func(int x)
{
	cout << "void Func(int x)" << endl;
}

test.cpp

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
//模板分离编译
#include"a.h"
//template<class T>
//T Add(const T& left, const T& right);
//
//
//void Func(int x);
int main()
{
	Add(1, 2);
	Add(1.0, 2.0);
	Func(10);
	return 0;
}

3.3 解决方法

3.1显示实例化（但是不好用）

a.h

cpp 复制代码 
#pragma once
#include<iostream>
using namespace std;
//函数模版
template<class T>
T Add(const T& left, const T& right);
void Func(int x);

a.cpp

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include"a.h"

//template<class T>
//T Add(const T& left, const T& right);
//
//
//void Func(int x);
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

void Func(int x)
{
	cout << "void Func(int x)" << endl;
}

//显示实例化
template
int Add(const int& left, const int& right);

template
double Add(const double& left, const double& right);

test.cpp

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
//模板分离编译
#include"a.h"
//template<class T>
//T Add(const T& left, const T& right);
//
//
//void Func(int x);
int main()
{
	cout<<Add(1, 2)<<endl;
	cout<<Add(1.0, 2.0)<<endl;
	//cout << Add('a', 'x') << endl;
	Func(10);
	return 0;
}
3.2 不要声明和定义到两个文件,直接定义在.h

本质：不存在链接要去找的问题，定义就在.h,在编译的时候就已经确定地址了。

a.h

cpp 复制代码 
#pragma once
#include<iostream>
using namespace std;
//函数模版
template<class T>
//T Add(const T& left, const T& right);
T Add(const T& left, const T& right)
{
	return left + right;
}

void Func(int x);

4. 模板总结

【优点】

  1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
  2. 增强了代码的灵活性
    【缺陷】
  3. 模板会导致代码膨胀问题，也会导致编译时间变长
  4. 出现模板编译错误时，错误信息非常凌乱，不易定位错误

总结

以上就是模版进阶（沉淀中）的全部内容了，喜欢这篇文章，可以一键三连，支持博主。

相关推荐
OpenC++1 小时前
【C++QT】Buttons 按钮控件详解
c++·经验分享·qt·leetcode·microsoft
YuforiaCode2 小时前
第十二届蓝桥杯 2021 C/C++组 直线
c语言·c++·蓝桥杯
草莓啵啵～3 小时前
搜索二叉树-key的搜索模型
数据结构·c++
共享家95273 小时前
深入理解C++ 中的list容器
c++
孞㐑￥3 小时前
C++11介绍
开发语言·c++·经验分享·笔记
云小逸3 小时前
【QQMusic项目界面开发复习笔记】第二章
c++·qt
李匠20243 小时前
C++ RPC以及cmake
网络·c++·网络协议·rpc
再睡一夏就好3 小时前
Linux常见工具如yum、vim、gcc、gdb的基本使用，以及编译过程和动静态链接的区别
linux·服务器·c语言·c++·笔记
YHY_13s4 小时前
访问者模式
c++·访问者模式
我也不曾来过14 小时前
list底层原理
数据结构·c++·list
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记08苍穹外卖面试总结09如何在WPS和Word/Excel中直接使用DeepSeek功能10【2025年最新】OpenWrt 更换国内源的指南（图形界面版)