模版进阶（沉淀中）

懒羊羊大王&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. 出现模板编译错误时，错误信息非常凌乱，不易定位错误

总结

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

相关推荐
owde17 小时前
顺序容器 -list双向链表
数据结构·c++·链表·list
GalaxyPokemon17 小时前
Muduo网络库实现 [九] - EventLoopThread模块
linux·服务器·c++
W_chuanqi17 小时前
安装 Microsoft Visual C++ Build Tools
开发语言·c++·microsoft
tadus_zeng18 小时前
Windows C++ 排查死锁
c++·windows
EverestVIP18 小时前
VS中动态库(外部库)导出与使用
开发语言·c++·windows
胡斌附体19 小时前
qt socket编程正确重启tcpServer的姿势
开发语言·c++·qt·socket编程
GalaxyPokemon19 小时前
Muduo网络库实现 [十] - EventLoopThreadPool模块
linux·服务器·网络·c++
守正出琦19 小时前
日期类的实现
数据结构·c++·算法
ChoSeitaku19 小时前
NO.63十六届蓝桥杯备战|基础算法-⼆分答案|木材加工|砍树|跳石头(C++)
c++·算法·蓝桥杯
热门推荐
01我决定放弃搞 Java 了02DeepSeek各版本说明与优缺点分析03如何在WPS和Word/Excel中直接使用DeepSeek功能04汽车上的各种质量：整备质量、总质量、装载质量、簧上质量、簧下质量05RAG 实践- Ollama+RagFlow 部署本地知识库06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07【AUTOSAR 基础软件】Can模块详解（Can栈之驱动模块）08本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程09DeepSeek RAGFlow构建本地知识库系统10Mac cursor设置jdk、Maven版本