【C++】—— 模版初阶

news2024/11/12 10:19:35

【C++】—— 模版初阶

  • 1 泛型编程
  • 2 函数模板
    • 2.1 函数模板基础用法
    • 2.2 模板的实例化
      • 2.2.1 隐式实例化(推导实例化)
      • 2.2.2 显式实例化
    • 2.3、函数模板的原理
    • 2.4、模板参数的匹配原则
  • 3 类模板
    • 3.1 类模板的定义格式
    • 3.2 实现栈类模板
    • 3.3 类模板为何优于 typedef
    • 3.4 类模板的实例化
    • 3.5 类模板的声明与定义分离

1 泛型编程

  类型的交换函数该怎么做?我们只能每一种类型都写一个,同时每个函数名都不能相同,无疑是非常繁琐的。C++中引入了函数重载,支持函数可以同名。
  
像这样:

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
} 
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
} 

//......

  C++ 有了函数重载比 C语言 方便多了,但还是有不足。如果还要进行其他类型,如 c h a r char char 类型的交换,那岂不是还要写一个函数?那多麻烦呀

函数重载的缺点:

  1. 重载的函数仅仅是类型不同,代码复用率比较低,只要有新类型出现时,就需要用户自己增加对应的函数
  2. 代码的可维护性比较低,一个出错可能所有的重载均出错

  
  那是否能告诉编译器一个模板,让编译器照着这个模板自己生成类似的函数呢?
  就像活字印刷一样,一印一个准

在这里插入图片描述

  为此,C++ 引入了模板的概念,并依次延伸出了泛型编程的思想
  泛型编程编写与类型无关的通用代码,是代码复用的一种手段,模板是泛型编程的基础
  
模板分为两类:函数模板类模板

在这里插入图片描述

  

2 函数模板

2.1 函数模板基础用法

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

  • t e m p l a t e template template < c l a s s class class 类型1, c l a s s class class 类型2,…, c l a s s class class 类型n>
  • 返回值类型 函数名(参数列表) { }

c l a s s class class 是用来定义模板参数的关键字,也可以用 t y p e n a m e typename typename (不能用 s t r u c t struct struct 代替 c l a s s class class)。 c l a s s class class t y p e n a m e typename typename 也可以混着用(正常人都不这么干)
  
  只看概念,往往比较抽象,我们来实践实现一个函数模板

template<class T>
void Swap(T& left, T& right)
{
	T tmp = left;
	left = right;
	right = tmp;
}

  T( t y p e type type)表示的是类型,当然,并一定非要用 T 来表示,也可以是 K 等其他字母。
  那 T 到底是什么类型呢?不知道,要看实例化

我们来学习模板可以用函数的参数列表来类比:

  • 函数参数列表(类型变量1,类型变量2, ···,类型变量n)
  • 模板参数列表<calss 类型1,calss 类型2,···,calss 类型n>

  
两个类型的模板:

template<class T1, class T2>
void func(const T1& x, const T2& y)
{
	;
}

  
  

2.2 模板的实例化

  用不同类型的参数使用函数模板时,称为函数模板的实例化
  模板的实例化又分为隐式实例化显式实例化
  

2.2.1 隐式实例化(推导实例化)

隐式实例化:让编译器根据实参推演模板参数的实际类型

  我们直接来看实例化代码:
模板:

template<class T>
T Add(T x, T y)
{
	return x + y;
}
int main()
{
	int a1 = 10, b1 = 5;
	double a2 = 6.0, b2 = 8.0;

	cout << Add(a1, b1) << endl;
	cout << Add(a2, b2) << endl;

	return 0;
}

  
运行结果:

在这里插入图片描述

  我们发现隐式的调用和正常函数的调用一模一样。
  编译器根据传递的两个实参 a a a b b b 都是 i n t int int 类型推断出模板中的 T 是int实例化相应函数。
  
那下面这样行不行呢?

int main()
{
	int a = 10;
	double b = 5.0;

	cout << Add(a, b) << endl;
	return 0;
}

  肯定是不行
  在编译期间,编译器实例化时,需要推演其实参类型
  通过 a a a 将 T 推演为 i n t int int,通过 b b b 将 T 推演为 d o u b l e double double
  但模板中只有一种类型 T
  编译器此时无法将 T 确定 i n t int int 还是 d o u b l e double double 而报错
  
:在模板中,编译器一般不会进行类型转换操作,因为一旦转换出问题,第一个背锅的就是编译器。、

此时有两种解决方法:

  1. 使用显式实例化
  2. 用户自己强制转化
//强制转化	
Add(a, (int)b);
Add((double)a, b);

  
  

2.2.2 显式实例化

显式实例化:在函数名后的<>指定模板参数的实际类型

int main()
{
	int a1 = 10, b1 = 5;
	double a2 = 6.0, b2 = 8.0;

	cout << Add<int>(a1, b1) << endl;
	cout << Add<double>(a2, b2) << endl;

	return 0;
}

  那显式实例化能传递两个不同类型吗?

可以的

int main()
{
	int a = 10;
	double b = 5.0;

	//显式实例化传递不同类型
	cout << Add<int>(a, b) << endl;
	return 0;
}

  这里, d o u b l e double double 进行隐式类型转换,转换成 i n t int int 类型

  当然,这里他们能够发生类型转换是因为他们的类型相近,都是用来表示数据大小。像是指针这种就不能发生隐式类型转换。

目前我们接触到达到的能发生隐式类型转换的就两类

  1. 浮点型整型之间
  2. 自定义类型单参数/多参数构造函数

: 如果类型不匹配,编译器会尝试进行隐式类型转换,如果无法转换成功编译器将会报错

  当然,这里更加推荐的是另写一个可以传递两个类型 A d d Add Add函数模板。

  有些情况是通过推导式推导不出参数类型的,必须显式实例化

template<class T>
T* func(int n)
{
	return new T[n];
}

  这时,编译器是不可能推导出你的返回类型的,必须显式实例化

int* p1 = func1<int>(10);

  

2.3、函数模板的原理

  函数模板的原理是什么呢?
  模板是一个蓝图,它本身并不是函数,是编译器根据使用方式产生特定函数的模具

  以前,我们想要实现不同类型的 S w a p Swap Swap 函数,要自己吭哧吭哧地去敲。现在,有了模板,编译器帮你生成了。
  模板其实就是将本来应该我们做的重复的事情交给编译器来做

在这里插入图片描述

  在编译阶段,编译器根据传入的实参类型来推演生成对应类型的函数以供调用。比如:当用 d o u b l e double double 类型使用函数模板时,编译器通过对实参类型的推演,将 T 确定为 d o u b l e double double 类型,然后产生一份专门处理 d o u b l e double double 类型的代码,对于其他类型也是如此。

template<class T>
void Swap(T& left, T& right)
{
	T tmp = left;
	left = right;
	right = tmp;
}

int main()
{
	int a1 = 10, b1 = 5;
	double a2 = 6.0, b2 = 8.0;

	Swap<int>(a1, b1);
	Swap<double>(a2, b2);

	return 0;
}

  像是Swap<int>(a1, b1)Swap<double>(a2, b2),他们调用的是同一个函数吗?
  我们通过底层汇编指令来看看

在这里插入图片描述

  可以看得到call指令跳转的地址是不一样的,说明他们调用的不是同一个函数

  
  

2.4、模板参数的匹配原则

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

// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
	return left + right;
}

int main()
{
	// 与非函数模板类型完全匹配,不需要函数模板实例化
	cout << Add(1, 2) << endl;

	// 模板函数可以生成更加匹配的版本,编译器根据实参生成更加匹配的Add函
	cout << Add(1, 2.0) << endl;
	return 0;
}

运行结果:

在这里插入图片描述

  
3. 模板函数不允许自动类型转换,但普通函数可以自动类型转换
  
  

3 类模板

3.1 类模板的定义格式

t e m p l a t e template template< c l a s s class class T1, c l a s s class class T2,···, c l a s s class class Tn>
c l a s s class class  类模板名
{
  // ···
}

 类模板的定义格式可以类比函数模板,这里不再过多解释

  
  

3.2 实现栈类模板

  我们实现一个栈类模板来感受一下

template<class T>
class Stack
{
public:
	//构造函数
	Stack(int n = 4)
		:_array(new T[n])
		, _capacity(n)
		,_size(0)
	{}

	//析构函数
	~Stack()
	{
		delete[] _array;
		_array = nullptr;
		_capacity = _size = 0;
	}

	//传参尽量引用,不改变尽量加const
	//T有可能是自定义类型
	void Push(const T& x)
	{
		//扩容
		//C++中没有renew的函数,需要自己实现扩容
		if (_size == _capacity)
		{
			T* tmp = new T[2 * _capacity];
			memcpy(tmp, _array, sizeof(T) * _size);
			delete[] _array;
			
			_array = tmp;
			_capacity *= 2;
		}

		_array[_size++] = x;
	}

private:
	T* _array;
	size_t _capacity;
	size_t _size;
};

  

3.3 类模板为何优于 typedef

  现在有一个问题:实现类模板与之前 t y p e d e f typedef typedef 有什么区别呢?
  如果我要在同一个层,一个栈中存 i n t int int 类型,一个栈存 d o u b l e double double 类型,那么只有类模板能做到

int main()
{
	Stack t1;//存int
	Stack t2;//存double

	return 0;
}

  
  

3.4 类模板的实例化

  类模板 只能显式实例化
  为什么呢?编译器:要不你来推导推导 T 是什么

类模板的显式实例化

int main()
{
	Stack<int> st1;
	st1.Push(1);
	
	Stack<double> st2;
	st2.Push(1.1);

	return 0;
}

  实例化后 s t 1 st1 st1 s t 2 st2 st2 不是同一个类型

  本质上,如果我们自己写也是不同的类。
  现在只是这些类很相似,编译器默默承担了这一切而已
  类模板与函数模板的原理是一样
  

3.5 类模板的声明与定义分离

  类模板成员函数声明与定义分离这样可以吗?

template<class T>
class Stack
{
public:
	//构造函数
	Stack(int n = 4)
		:_array(new T[n])
		, _capacity(n)
		,_size(0)
	{}

	//析构函数
	~Stack()
	{
		delete[] _array;
		_array = nullptr;
		_capacity = _size = 0;
	}

	void Push(const T& x);
	

private:
	T* _array;
	size_t _capacity;
	size_t _size;
};


void Stack::Push(const T& x)
{
	//扩容
	//C++中没有renew的函数,需要自己实现扩容
	if (_size == _capacity)
	{
		T* tmp = new T[2 * _capacity];
		memcpy(tmp, _array, sizeof(T) * _size);
		delete[] _array;

		_array = tmp;
		_capacity *= 2;
	}

	_array[_size++] = x;
}

  是不行的,因为template<class T>定义的模板 只能给当前的模板用

  我们要在类外定义的成员函数前再定义模板,并且指定类域

template<class T>
class Stack
{
public:
	//构造函数
	Stack(int n = 4)
		:_array(new T[n])
		, _capacity(n)
		,_size(0)
	{}

	//析构函数
	~Stack()
	{
		delete[] _array;
		_array = nullptr;
		_capacity = _size = 0;
	}

	void Push(const T& x);
	

private:
	T* _array;
	size_t _capacity;
	size_t _size;
};

template<class T>
void Stack<T>::Push(const T& x)
{
	//扩容
	//C++中没有renew的函数,需要自己实现扩容
	if (_size == _capacity)
	{
		T* tmp = new T[2 * _capacity];
		memcpy(tmp, _array, sizeof(T) * _size);
		delete[] _array;

		_array = tmp;
		_capacity *= 2;
	}

	_array[_size++] = x;
}

   P u s h Push Push 函数的 T 可全部换成其他标识,如:X。因为具体实例化后 T 是一个具体的类型,实例化能匹配上就可以了,它不管当前的模板是 T 还是 X

template<class X>
void Stack<X>::Push(const T& x)
{
	
	if (_size == _capacity)
	{
		X* tmp = new X[2 * _capacity];
		memcpy(tmp, _array, sizeof(X) * _size);
		delete[] _array;

		_array = tmp;
		_capacity *= 2;
	}

	_array[_size++] = x;
}

  但最好别这么做,容易被打,最好和前文保持一致

:类模板不建议声明和定义分离到两个文件 (.h.cpp),会出现链接错误
  
  
  
  
  


  好啦,本期关于模版的知识就介绍到这里啦,希望本期博客能对你有所帮助。同时,如果有错误的地方请多多指正,让我们在C语言的学习路上一起进步!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2084478.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

部署Alertmanager发送告警

1、Alertmanager简介 Prometheus 对指标的收集、存储与告警能力分属于 Prometheus Server 和 AlertManager 两个独立的组件&#xff0c;前者仅负责定义告警规则生成告警通知&#xff0c; 具体的告警操作则由后者完成。 Alertmanager 负责处理由 Prometheus Server 发来的告警…

【Java设计模式】Builder模式:在Java中清晰构建自定义对象

文章目录 【Java设计模式】Builder模式&#xff1a;在Java中清晰构建自定义对象一、概述二、Builder设计模式的意图三、Builder模式的详细解释及实际示例四、Java中Builder模式的编程示例五、Builder模式类图六、Java中何时使用Builder模式七、Builder模式的优点和权衡八、源码…

【STM32开发笔记】STM32H7S78-DK上的CoreMark移植和优化--兼记STM32上的printf重定向实现及常见问题解决

【STM32开发笔记】STM32H7S78-DK上的CoreMark移植和优化--兼记STM32上的printf重定向实现及常见问题解决 一、CoreMark简介二、创建CubeMX项目2.1 选择MCU2.2 配置CPU时钟2.3 配置串口功能2.4 配置LED引脚2.5 生成CMake项目 三、基础功能支持3.1 支持记录耗时3.2 支持printf输出…

三个令人破防的真理

1、所有的人都倡导正义这是不是一件好事呢&#xff1f; 答案肯定是否定的&#xff0c;因为倡导正义不等于践行正义&#xff0c;很多人都倡导&#xff0c;那你做好事是很不容易拿到结果的&#xff0c;相反&#xff0c;你如果做坏事&#xff0c;你是非常容易拿到结果的。 我们的…

stm32f103c8t6 pid算法控制温度详解

目录 1. 硬件准备 必要的硬件组件: 接线示例: 2. PID算法简介 3. 软件实现 初始化和配置 PID控制算法实现 4. 调试和优化 调试步骤: 参数调整技巧: 5. 结论 在使用STM32F103C8T6微控制器进行温度控制时,PID(比例-积分-微分)算法是一种常见且有效的控制方法。…

深度学习——大模型分词

1. 前言 自从chatgpt出现&#xff0c;大模型的发展就进入了快车道&#xff0c;各种各样的大模型卷上天&#xff0c;作为一个在大模型时代的科研人&#xff0c;即使你不向前&#xff0c;也会被时代裹挟着向前&#xff0c;所以还是自己走快一点比较好&#xff0c;免得被后浪拍死…

黑神话悟空配置要求高吗? 配置要求介绍

《黑悟空神话》这款游戏从实机演示中可以看出对配置要求并不低&#xff0c;可以根据当前上市的游戏来推断出该游戏的配置要求。 1、推荐配置&#xff1a; 操作系统:Windows 7, Windows 8.1, Windows 10(均为64位) 处理器: Intel Core i5-6600K / AMD Ryzen 5 1600 内存: 16 …

vue后台项目打包成桌面应用程序(.exe)

目录&#xff08;本项目基于vue2&#xff09; 1、打包成功后的样子​ 2、开发环境 3、开发流程&#xff08;serve build 基础设置 系统托盘&#xff09; 4、插件下载地址 5、打包后的配置文件: 6、镜像 1、打包成功后的样子 2、开发环境 node&#xff1a;14.18.1 elec…

“等保”??到底保什么?简单了解信息安全等级保护

若已部署了畅云管家的企业需要做“等保”&#xff0c; 我们可提供注册等保所需材料 若有需求请咨询所属服务商 等级保护&#xff08;简称“等保”&#xff09; 简单总结&#xff1a;等保就是信息安全等级保护&#xff0c;网络安全法要求网络运营者应当按照网络安全等级保护…

告别复杂编程,低代码平台如何简化列表页多模型数据配置

在现代企业管理和信息系统建设中&#xff0c;随着业务复杂度的不断提升&#xff0c;单一数据模型往往难以满足复杂的数据展示需求。特别是在构建企业级应用或管理平台时&#xff0c;经常需要在一个界面上综合展示来自多个数据模型的信息&#xff0c;以便用户能够更全面地理解业…

OCR智能合同比对工具——快速比对合同差异点

在现代商业活动中&#xff0c;合同是确保交易双方权益和责任的重要法律文件。随着商业活动的复杂性增加&#xff0c;合同版本更新和修订变得越来越频繁。法务、采购等合同经办部门在处理合同时&#xff0c;往往面临着以下挑战&#xff1a; 1.版本一致&#xff1a;随着合同的不…

操作系统面试真题总结(一)

文章收录在网站&#xff1a;http://hardyfish.top/ 文章收录在网站&#xff1a;http://hardyfish.top/ 文章收录在网站&#xff1a;http://hardyfish.top/ 文章收录在网站&#xff1a;http://hardyfish.top/ 什么是用户态和内核态 用户态和内核态是操作系统的两种运行状态。…

Redis_AOF持久化

AOF持久化 在AOF持久化的过程中&#xff0c;会以日志的方式记录每个redis“写”命令&#xff0c;并且redis服务器重启时重新执行AOF日志文件中的命令&#xff0c;从而达到“恢复数据”的效果 AOF故障恢复 当redis因发生故障而重启时&#xff0c;redis服务器会按照如下步骤根据…

演绎法推理

cp规则&#xff1a;给前提集合&#xff0c;给结论&#xff0c;要求推导前提推导结论。把结论化成蕴含式&#xff0c;里面的蕴含前件为真拿下来做补充条件&#xff0c;再和前提集合里面那么多条件一起推&#xff0c;最后推出那个结论为真。

【吊打面试官系列-Redis面试题】Redis 的数据类型?

大家好&#xff0c;我是锋哥。今天分享关于 【Redis 的数据类型&#xff1f;】面试题&#xff0c;希望对大家有帮助&#xff1b; Redis 的数据类型&#xff1f; 答&#xff1a;Redis 支持五种数据类型&#xff1a;string&#xff08;字符串&#xff09;&#xff0c;hash&#x…

常见的服务器容器和漏洞类型汇总

常见的服务器容器和漏洞有哪些&#xff1f;常见的服务器容器包括KubeSphere、Tomcat、Nginx、Apache等&#xff0c;它们在提供便捷的服务部署和灵活的网络功能的同时&#xff0c;也可能存在着一定的安全风险。这些容器的漏洞可能导致数据泄露、权限被非授权访问甚至系统被完全控…

深入京东API世界:商品详情返回值的秘密

京东API世界中的商品详情返回值是一个复杂而精细的数据体系&#xff0c;它承载着商品的全面信息&#xff0c;对于商家、用户以及开发者而言&#xff0c;都具有极高的价值。下面&#xff0c;我们将深入探索京东商品详情API返回值的秘密。 基本结构概述 京东商品详情API的返回值…

【工控】线扫相机小结 第二篇

背景 上一篇中《线扫相机小结》中介绍了一些基础知识和注意事项&#xff0c;这一篇是对上一篇的进一步补充。 会介绍线扫相机的一些调试技巧。 如何在线调试&#xff1f; 我们知道&#xff0c;线扫相机不能像面阵相机一样实时的呈现图像&#xff0c;只能一行行的扫描&#x…

谷歌的搜索语法

谷歌搜索常用语法 谷歌提供了多种搜索语法&#xff0c;帮助用户更精确地查找所需内容。以下是一些常用语法的介绍和示例&#xff1a; 1. 精确匹配&#xff1a;使用双引号 " " 在搜索内容时&#xff0c;如果需要精确匹配某个词组&#xff0c;可以将其放在双引号内。 …

BaseCTF 高校联合新生赛 Week1

Week1 Web [Week1] HTTP BaseCTF{4248fc3d-a280-4de0-b5e6-6ff0ecaa1fca} [Week1] 喵喵喵•&#xfecc;• [Week1] md5绕过欸 [Week1] A Dark Room [Week1] upload 什么过滤都没有&#xff0c;上传一句话木马即可 [Week1] Aura 酱的礼物 卡在SSRF那里&#xff0c; 我想用…