一文搞懂模板(template)

已于 2023-11-26 16:06:50 修改
阅读量889 收藏 11
点赞数 4
分类专栏： C++ 文章标签： java 开发语言 c++
于 2023-09-26 19:04:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45153969/article/details/132914542
版权

背景引入：
想象一下，我们要实现一个整数相加，浮点数相加的函数，如果按C语言的思路，我们需要写两个函数名不同的函数，来完成相加；如果C++语言，则可以通过函数重载的特性，写两个函数名相同，但参数列表不同的函数，来完成任务。
不管怎么样，我们都需要实现两个函数？

那么我们可以只写一个通用的函数，来完成这个任务吗？
接下来就要请模板出场！

template

1. 模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特性类型版本。

2. 使用方法

使用如下方法定义函数模板，并且可以根据需要定义多个模板参数。
template<class A, class B…>

template<class T>    //template<typename T>   也可以
T Add(T x, T y)
{
	return x + y;
}

3. 模板原理

在编译器编译阶段，对于函数模板的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
例如：当使用double类型使用函数模板时，编译器通过对实参推演，会自动生成一份double类型的函数，以供调用。
在这里插入图片描述

template<class T>    //template<typename T>   也可以
T Add(T x, T y)
{
	return x + y;
}


int main()
{

	int a = 10;
	int b = 11;

	double c = 1.1;
	double d = 2.2;

	Add(a, b);
	Add(c, d);
	return 0;
}

在这里插入图片描述

从上面的例子可以看出，编译器确实自动生成了两个参数不同的函数（因为调用地址不同）。

4. 模板实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

4.1 隐式实例化

让编译器根据实参类型，自己推演。

template<class T>    //template<typename T>   也可以
T Add(T x, T y)
{
	return x + y;
}


int main()
{

	int a = 10;
	int b = 11;

	double c = 1.1;
	double d = 2.2;

	Add(a, b);  // 生成整形模板
	Add(c, d);   //生成double模板
	Add(a, d);   // 编译报错，因为a是int，b是double，只有一个模板T，编译器不知道生成哪个。
	// 解决方法：
	//1.用户自己来强制转化
	Add(a, (int)d);
	//2. 使用显示实例化
	return 0;
}

4.2 显式实例化

在函数名后的<>中指定模板参数的实际类型。

int a = 10;
double b =1.1;
Add<int>(a, b);   //显示实例化
// 如果类型不配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器会自动报错。

5. 模板参数匹配规则

  1. 一个非模板参数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
// 专门处理int的加法函数
int Add(int left, int right)
{
 return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
 return left + right;
}
void Test()
{
 Add(1, 2); // 与非模板函数匹配，编译器不需要特化
 Add<int>(1, 2); // 调用编译器特化的Add版本
}
  1. 对于非模板函数和同名函数模板，如果其他条件都相同，在调用时优先调用非模板函数而不会从模板特化一个实例；如果模板可以产生一个更合适的函数，那么选择模板。
// 专门处理int的加法函数
int Add(int left, int right)
{
 return left + right;
}


// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
 return left + right;
}
void Test()
{
 Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
 Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函
数
}
  1. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

6. 类模板

6.1 定义格式

类模板不是真正的类，而实例化的结果才是真正的类。

template<class T1, class T2, ..., class Tn>
class A
{
 // 类内成员定义
};

实例化一个类型为A的a对象，类型要求为int。

A<int> a;
// A 类名，A<int> 才是类型

7.模板参数

  • 类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
  • 非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
namespace xty
{
	template<class T, size_t N = 10>
	class array
	{
	public:
		T& operator[](size_t index) { return _array[index]; }
		const T& operator[](size_t index)const { return _array[index]; }
		size_t size() { return _size; }
		bool empty()const { return _size == 0; }

	private:
		T _array[N];
		size_t _size;
	};
}


int main()
{

	xty::array<int, 20> a1;
	xty::array<int> a2;
	return 0;
}

该段代码能够成功编译，并且我们通过_array[N]，也能感受到，模板参数N是一个常量，并且该位置必须是整型常量(int, size_t, long, long long, char)。

注意：

  1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
  2. 非类型的模板参数必须在编译器就能确认结果。

8.模板特化

模板的特殊化处理，即给模板参数进行进一步的限制或者给模板参数赋值具体的类型。
分为：函数模板特化和类模板特化

首先看一个例子：


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, 10) << 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;
}

首先这种情况，只有一个类型的比较函数肯定是不够的，我们可以使用仿函数来解决这个问题。但是这样会造成创建对象的时候多写一个参数。现在我们可以有一个新的方式来解决这个问题。请继续往下阅读：

8.1函数模板特化

函数模板特化步骤：

  1. 必须要先有一个基础的函数模板
  2. 关键字template后面接一对空的尖括号<>
  3. 函数名后面跟一对尖括号，尖括号中要指定特化的类型。
  4. 函数形参列表：必须要和模板函数的基础参数类型完全相同。

如下改正即可解决上面的问题：

// 基础模板
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

//特化模板
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

但是上面的形式很明显有一点冗余，我们可以使用函数重载同样能够解决问题。因此我们不建议函数模板进行特化。
改正版本如下：

// 基础模板
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

特化模板
//template<>
//bool Less<Date*>(Date* left, Date* right)
//{
//	return *left < *right;
//}

//函数重载
bool Less(Date* left, Date* right)
{
	return *left < *right;
}

8.2 类模板特化

8.2.1全特化

全特化是将模板参数列表中所有的参数都确定化。
如下示例：

template<class T1, class T2>
class Xxx
{
public:
	Xxx()
	{
		cout << "Xxx<T1, T2>";
	}

private:
	T1 _t1;
	T2 _t2;
};

//全特化
template<>
class Xxx<char, int>
{
public:
	Xxx()
	{
		cout << "Xxx<char, int>";
	}

private:
	char _t1;
	int _t2;
};




void Test()
{
	Xxx<int, int> d1;
	Xxx<char, int> d2;
}

在这里插入图片描述
类实例化时，会根据具体的类型会调用最合适的类模板。

8.2.2偏特化

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


//基础模板
template<class T1, class T2>
class Xxx
{
public:
	Xxx()
	{
		cout << "Xxx<T1, T2>"<<endl;
	}

private:
	T1 _t1;
	T2 _t2;
};


// 部分特化，只特化模板参数列表中的一部分参数
template<class T1>
class Xxx<T1, int>
{
public:
	Xxx()
	{
		cout << "Xxx<T1, int>" << endl;
	}

private:
	T1 _t1;
	int _t2;
};

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

private:
	T1 _t1;
	T2 _t2;
};

//两个参数偏特化为引用类型

template<class T1, class T2>
class Xxx<T1&, T2&>
{
public:
	Xxx(const T1& d1, const T2& d2)
		:_t1(d1)
		,_t2(d2)
	{
		cout << "Xxx<T1&, T2&>" << endl;
	}

private:
	const T1& _t1;
	const T2& _t2;
};



void Test()
{
	Xxx<double, int> d1;   //调用特化的int版本
	Xxx<int, double> d2;   //调用基础的模板
	Xxx<int*, int*> d3;    //调用特化的指针版本
	//传进去的1， 2为常量，不能改变，需要用const接收
	Xxx<int&, int&> d4(1, 2);   // 调用特化的引用版本
}

在这里插入图片描述

9.模板分离编译

9.1 分离编译概念

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

9.2 模板的分离编译

先给结论：模板不能分离编译，即模板的声明在a.h文件中，模板的定义在a.cpp文件中，编译不通过！

如下示例：


//a.h

template<class T>
T Add(const T& left, const T& right);
void Func();

//a.cpp
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
void Func()
{
	std::cout << "Func()" << std::endl;
}

//main.cpp
int main()
{

	Add(1, 2);
	Add(1.1, 2.2);
	Func();
	return 0;
}

分析：
c/cpp程序运行，要经历：预处理->编译->汇编->链接
预处理：.i文件，宏替换，头文件替换。
编译：.s文件，对程序进行词法、语法、语义分析，检查无误后生成汇编代码，注意头文件不参与编译，编译器对工程中的多个源文件时分离开单独编译的。
汇编：是.o文件，各个.o文件会生成符号表。
链接：将多个obj文件合并成一个（通过符号表的地址去找），并处理没有解决的地址问题。

在这里插入图片描述

因此普通函数可以编译通过，但声明定义分离的模板就不能编译通过。

9.3 解决办法

  1. 将声明和定义的位置放到一个文件“xxx.hpp”或者xxx.h也可以。
  2. 在模板定义的位置显示实例化。不太实用，推荐方法1。

方法一举例：


//a.hpp文件改成这样
template<class T>
T Add(const T& left, const T& right);



void Func();


template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}


void Func()
{
	std::cout << "Func()" << std::endl;
}


//声明和第一放在一起，直接就可以实例化，编译时就有地址，不需要链接

方法二举例：

//a.cpp文件改成这样

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}


void Func()
{
	std::cout << "Func()" << std::endl;
}


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

template
int Add<int>(const int& left, const int& right);

最粗暴的方法：


//main.cpp直接将模板声明和定义放在main.cpp中
template<class T>
T Add(const T& left, const T& right);

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

int main()
{

	Add(1, 2);  //直接生成地址，不需要链接去找
	Add(1.1, 2.2); 
	Func();  //此时func（）需要链接上地址，去找定义，才能运行。
	return 0;
}

总结

优点：

  1. 模板服用了代码，节省资源，更快的迭代开发，C++的标准模板库（STL）因此而产生。
  2. 增强代码的灵活性

缺点：

  1. 模板会导致代码膨胀问题，一份模板会实例化出好多代码，也会导致编译时间变长。
  2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误！
羊羊羊i
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
模板模式（Template）
m0_65979836的博客
04-22 1067
术语 template：模板 模板模式UML类图 角色 AbstractClass 抽象类实现了模板方法(template)，定义了算法的骨架，具体子类需要去实现 其它的抽象方法 ConcreteClass 2)实现抽象方法 , 以完成算法中特点子类的步骤 案例 需求：统计某一代码运行时间 使用前后对比 所以前: package com.javatf.design.template.before; /** * @author ...
一文搞懂Raft算法
01-27
raft是工程上使用较为广泛的强一致性、去中心化、高可用的分布式协议。在这里强调了是在工程上，因为在学术理论界，最耀眼的还是大名鼎鼎的Paxos。但Paxos是：少数真正理解的人觉得简单，尚未理解的人觉得很难，...
C++ 模板保姆级详解——template＜class T＞(什么是模板？模板分哪几类
最新发布
2401_84976219的博客
05-15 520
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！ 网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取
定义模板
cwbguaijie的专栏
12-15 343
模板是C++中泛型编程的基础。一个模板就是一个创建类或函数的蓝图或者说公式。 定义模板 编写一个函数来比较两个值 int compare(const string &v1,const string &v2) {     if(v1     if(v2     return 0; } int compare(const double &v1,const double &
C++ 模板(template) 的定义
日拱一卒,功不唐捐
11-05 3397
定义： 模板（template）是实现代码重用机制的一种工具，它可以实现类型参数化，把类型定义为参数（模板元编程），从而实现了真正的代码可重用性。 模板是用来批量生成功能和形式都几乎相同的代码的。编译器就能在需要的时候，根据模板自动生成程序的代码。从同一个模板自动生成的代码，形式几乎是一样的。 模板就像一个做饼干的模具，至于饼干是什么味道，则要看具体实例化时制作饼干的材料。 模板可以分为两类...
C++中带有空尖括号的template ＜＞
Lekaor的博客
06-14 1785
模板特化template
template详解
TonyaBaSy
05-07 4806
1. 函数模板1. 函数模板定义关键字：“template开头”，“参数列表非空” 定义一定要以：template<…>开头（为了解释为什么 inline 在第 2 位置） 定义中模板参数列表不能为空（模板特例化中参数列表可以为空）。template<tempname T> inline T funcName(const T &a, const T &b) { return (a + b);
一文搞懂混合动力汽车
01-14
经过4S店销售的一顿狂轰乱炸，你还是搞不懂混合动力汽车有插电式与非插电式之分，还有串联式、并联式、混联式的区别。 无妨，接着看下文也许你就懂了！ 混合动力汽车透视图 传统汽车由内燃机燃烧...
一文搞懂C语言回调函数
01-27
回调函数在C语言中是一种强大的编程机制，它允许我们将函数作为参数传递给其他函数，然后在特定条件下由这些函数调用。回调函数的核心是函数指针，它存储了函数的地址，使得其他函数可以通过这个地址来执行指定的...
网络知识扫盲，一文搞懂DNS
01-27
【网络知识扫盲，一文搞懂DNS】 网络知识在面试中扮演着至关重要的角色，尤其是在IT行业。本文旨在帮助那些在网络知识上遇到困难的同学，尤其是关于DNS的基础知识。DNS，全称为Domain Name System，是一种分布式...
Template类模板
senjay的博客
05-21 5869
Template1.函数模板2.类模板3.成员模板4.嵌套类模板5.总结 1.函数模板 编译期间编译器自动分析参数类型，template函数模板是支持默认参数的，T1 、T2 顺序在默认情况下是可以任意的，不用严格按照从右到左的顺序，例如：template <typename T1 ,typename T2 = int> //函数模板化 template<typename T> T add(const T lval,const T rval) { T ans = lv
数据结构---模板(template)
qq_51929114的博客
02-02 1575
函数模板是参数化的函数。template < 模板形参表 > 返回值类型 函数名(参数表) {函数体 }template < typename T > //模板定义，T为模板参数 T abs(T a) {//定义函数模板 return a < 0?- a : a；- a : a；- a : a；x : y;cout
有趣算法之C++函数模板
Xor0ne
10-02 1128
C++函数模板 20200924 原文链接：https://www.runoob.com/w3cnote/c-templates-detail.html （原文正在慢慢理解中……） 模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。 模板是一种对类型进行参数化的工具，通常有两种形式：函数模板和类模板； 函数模板针对仅参数类型不同的函数； 类模板针对仅数据成员和成员函数类型不同的类。 ...
设计模式-模板模式（Template）介绍和使用
旭东怪的博客
04-15 1813
目录 1模板模式（Template） 2 抽象Template类 3 具体Template类 3.1 TemplateA类 3.2 TemplateB类 3.3 TemplateC类 3.4 TemplateD类 4 调试代码 5 调试结果 注： 1模板模式（Template） 意图：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 主要解决：一些方法通用，却在每一个子类都重新写了这...
方法返回值前面的＜T＞是什么？浅谈泛型模板T
Asunakiritolove的博客
03-20 914
//Java 方法返回值前面的T是什么 TODO 它的作用是定义泛型 class Show<T>{ public void print1(T t){ System.out.println(t); } public <T>void print2(T t){ System.out.println(t); } } class Demo{ public static void main(String[] args) {.
Go template详解（上）- 注释、作用域、空格和空行、管道、{{range .}}、{{with .}}（helm进阶语法）
运维玄德公
08-29 2907
1. 注释 {{/* xxxx */}} 2. 作用域 2.1 顶级作用域 {{ . }} 2.2 相对作用域 {{range . }} xxxx {{end}} 2.3 切换作用域 {{with .xxx }} xxx {{end}} 3. 去空格和去空行 {{- xxx}} 3.1 去空行 3.2 去空格 4. 管道 {{ | }}
C++ 模板详解（一）
weixin_33699914的博客
10-25 1448
C++模板 　　模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。 　　模板是一种对类型进行参数化的工具； 　　通常有两种形式：函数模板和类模板； 　　函数模板针对仅参数类型不同的函数； 　　类模板针对仅数据成员和成员函数类型不同的类。 　　使用模板的目的就是能够让程序员编写与类型无关的代码。...
＜template＞标签的用法
walkinging1的博客
08-23 2357
web前端＜template＞标签的用法
vscode中.vue文件的template添加注释出错问题解决（已安装vetur）
zjuwwj的博客
08-24 6825
1. 现象 已经安装了vetur，但是给.vue文件的template添加注释还是有问题，网上查的说是插件冲突，卸载后重新安装依然无效；还有的是在settings.js里配置一堆东西，尝试了也是无效。 2. 解决方法 尝试了这个办法后，终于生效了，在vscde的settings.json里添加如下代码： "files.associations": { "*.vue": "html" } 喜大普奔，生效了！ 3. 其他 功夫不负有心人，开心最重要。 ...
template
05-29
<> 标签是 HTML5 中的一个元素，用于定义模板。模板是一段可重用的 HTML 代码，可以在不同的地方多次使用。通常，<template> 元素中的内容不会在页面加载时被渲染，而是在 JavaScript 中进行操作。 <template> 元素可以包含任何 HTML 元素，但是其中的内容不会在页面中呈现。相反，可以使用 JavaScript 来操作模板中的内容，例如复制、删除或替换其中的元素，以及在页面中插入新的元素。 以下是一个简单的示例，展示了如何使用 <template> 元素： ``` <template id="myTemplate"> <h2>这是一个标题</h2> <p>这是一个段落。</p> </template> <div id="myDiv"></div> <script> // 复制模板内容并插入到页面中 var template = document.querySelector('#myTemplate'); var content = template.content.cloneNode(true); document.querySelector('#myDiv').appendChild(content); </script> ``` 以上代码将创建一个包含标题和段落的模板，并将其存储在 <template> 元素中。然后，使用 JavaScript 获取模板的内容并将其插入到页面中。注意，<template> 元素必须具有一个 id 属性，以便通过 JavaScript 访问它。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值