C++模板初阶学习

最新推荐文章于 2024-07-22 10:02:43 发布
最新推荐文章于 2024-07-22 10:02:43 发布
阅读量131 收藏 1
点赞数 2
分类专栏： C++初阶学习 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74288306/article/details/131885805
版权

目录

1.函数模板

如何实现一个通用的交换函数呢？

#include<iostream>
using namespace std;
void Swap(int& p1, int& p2)
{
	int tmp = p1;
	p1 = p2;
	p2 = tmp;
}
void Swap(double& p1, double& p2)
{
	double tmp = p1;
	p1 = p2;
	p2 = tmp;
}
void Swap(char& p1, char& p2)
{
	char tmp = p1;
	p1 = p2;
	p2 = tmp;
}
int main()
{
	int a = 10, b = 20;
	cout << "a=" << a << " " << "b=" << b << endl;
	Swap(a, b);
	cout << "a=" << a << " " << "b=" << b << endl;
	double c = 10.1, d = 20.2;
	cout << "c=" << c << " " << "d=" << d << endl;
	Swap(c, d);
	cout << "c=" << c << " " << "d=" << d << endl;
	char x = 'a', y = 'b';
	cout << "x=" << x << " " << "y=" << y << endl;
	Swap(x, y);
	cout << "x=" << x << " " << "y=" << y << endl;
	return 0;
}

代码运行的结果为：
在这里插入图片描述
使用函数重载虽然可以实现，但是有一下几个不好的地方：

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

我们可以使用以下代码实现：

template<class T>
void Swap(T& p1, T& p2)
{
	T tmp = p1;
	p1 = p2;
	p2 = tmp;
}
int main()
{
	int a = 10, b = 20;
	cout << "a=" << a << " " << "b=" << b << endl;
	Swap(a, b);
	cout << "a=" << a << " " << "b=" << b << endl;
	double c = 10.1, d = 20.2;
	cout << "c=" << c << " " << "d=" << d << endl;
	Swap(c, d);
	cout << "c=" << c << " " << "d=" << d << endl;
	char x = 'a', y = 'b';
	cout << "x=" << x << " " << "y=" << y << endl;
	Swap(x, y);
	cout << "x=" << x << " " << "y=" << y << endl;
	return 0;
}

代码运行的结果为：
在这里插入图片描述
上面的代码也可以实现不同类型的交换，其中涉及了模板的知识点，接下来我们一起学习一下。

1.1函数模板概念

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

1.2函数模板格式

template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}

template<typename T>//模板参数--类型
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}

其中，typename是用来定义模板的关键字，也可以使用class，不能使用struct代替class。

1.3函数模板的原理

在上面的代码中，我们使用函数模板调用不同类型的数据进行交换，调用的是同一个函数吗？
汇编代码：

	int a = 10, b = 20;
001227FF  mov         dword ptr [a],0Ah  
00122806  mov         dword ptr [b],14h  
	//cout << "a=" << a << " " << "b=" << b << endl;
	Swap(a, b);
0012280D  lea         eax,[b]  
00122810  push        eax  
00122811  lea         ecx,[a]  
00122814  push        ecx  
00122815  call        std::operator<<<std::char_traits<char> > (0121460h)  
0012281A  add         esp,8 
	double c = 10.1, d = 20.2;
0012281D  movsd       xmm0,mmword ptr [__real@4024333333333333 (0129B48h)]  
00122825  movsd       mmword ptr [c],xmm0  
0012282A  movsd       xmm0,mmword ptr [__real@4034333333333333 (0129B58h)]  
00122832  movsd       mmword ptr [d],xmm0  
	//cout << "c=" << c << " " << "d=" << d << endl;
	Swap(c, d);
00122837  lea         eax,[d]  
0012283A  push        eax  
0012283B  lea         ecx,[c]  
0012283E  push        ecx  
0012283F  call        Swap<char> (012145Bh)  
00122844  add         esp,8

在编译器编译阶段，编译器根据传入的参数，推导出对应的模板参数类型，从而实例化出具体的函数！
在这里插入图片描述
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

1.4函数模板实例化

实现Add()函数不同类型的数据相加
eg1:

template <class T1,class T2>
T1 Add(T1& x1, T2& x2)
{
	return x1 + x2;
}
int main()
{
	int a = 10;
	double d = 20.1;
	cout << Add(a, d) << endl;
	return 0;
}

代码运行的结果为：
在这里插入图片描述
eg2：

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a = 10;
	double d = 20.1;
	cout << Add(a, d) << endl;
	return 0;
}

代码编译运行的结果：
在这里插入图片描述

当函数模板只有一个参数时，而传递不同类型的实参，编译器因调用不明确而无法推导实例化出具体函数而报错，这就涉及函数模板实例化问题。

函数模板实例化概念：

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

隐式实例化

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

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a = 10;
	double d = 20.1;
	cout << Add(a, (int)d) << endl;//强制类型转换
	return 0;
}

通过强制类型转换，是传递的数据为同一类型，编译器便可以实例化出具体的函数，需要注意的是强制类型转换的临时变量具有常性，函数参数需要加const修饰，以上便是隐式实例化的过程。

显示实例化

显示实例化：在函数名后的<>中指定模板参数的实际类型
eg1：

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
void Test()
{
	int a = 10;
	double d = 20.1;
	cout << Add<int>(a, d) << endl;
}

代码编译运行的结果为：
在这里插入图片描述

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

eg2：

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

int main()
{
	int* p = Alloc(10);
	return 0;
}

在这里插入图片描述
以上的代码就不能通过隐式实例化调用模板函数，需要通过函数实例化才能调用。
正确的调用方式：

T* Alloc(int n)
{
	return new T[n];
}

int main()
{
	int* p = Alloc<int>(10);
	return 0;
}

1.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版本
}

2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板

// 专门处理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函数
}

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

// 专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}
void Test()
{		
	Add(1, 2.0); // 调用普通函数，编译器会自动转换类型
}

//同类型加法函数
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
void Test()
{		
	Add(1, 2.0); 
	//调用模板函数，编译器不会自动强转而报错，需要自己手动强转或显示实例化
}

2.类模板

2.1类模板的定义格式

eg1：

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

实现不同类型的栈：

typedef int DataType;
class StackInt
{
public:
	StackInt(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	// 其他方法...

	~StackInt()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	DataType* _array;
	int _capacity;
	int _size;
};

typedef double DataType;
class StackDouble
{
public:
	StackDouble(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	// 其他方法...

	~StackDouble()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	StackInt s1; // int
	StackDouble s2; // double

	return 0;
}

平时我们实现要使用栈存储不同类型的数据的时候，需要不同的栈的才能实现，需要对已有其他类型的栈进行相应的修改，即类名以及函数名都要修改；当我们需要添加不同功能函数时，不同的栈都要实现一遍，我们可以使用类模板解决这个问题！

eg2：

template<class T>
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (T*)malloc(sizeof(T) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

	void Push(T data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	// 其他方法...

	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	T* _array;
	int _capacity;
	int _size;
};
int main()
{
	Stack<int> s1; // int
	Stack<double> s2; // double
	return 0;
}

使用类模板实现不同类型的栈，需要显示实例化。

eg3:

template<class T>
class Stack
{
public:
//声明
	Stack(size_t capacity = 3);

	void Push(T data);

	// 其他方法...

	~Stack();

private:
	T* _array;
	int _capacity;
	int _size;
};
//定义
template<class T>
Stack<T>::Stack(size_t capacity)
{
	_array = (T*)malloc(sizeof(T) * capacity);
	if (NULL == _array)
	{
		perror("malloc申请空间失败!!!");
		return;
	}

	_capacity = capacity;
	_size = 0;
}
template<class T>
void Stack<T>::Push(T data)
{
	// CheckCapacity();
	_array[_size] = data;
	_size++;
}
template<class T>
Stack<T>::~Stack()
{
	if (_array)
	{
		free(_array);
		_array = NULL;
		_capacity = 0;
		_size = 0;
	}
}
int main()
{
	Stack<int> s1; // int
	Stack<double> s2; // double
	return 0;
}

使用类模板，要实现类成员函数声明和定义分离：①要指定函数的类模板域，如上代码需要在函数名前面加上Stack<int>::②类模板的作用域在最近的{}域里面，在类外面实现成员函数，需要结合类模板一起实现。

2.2类模板实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

//类模板与普通类的区别
//普通类：类名和类型一样，如用普通类实现栈，类名和类型都为Stack
//类模板：类名和类型不同，如用类模板实现栈，类名为Stack,类型为Stack<T>
//类模板实例化
Stack<int> s1; // int
Stack<double> s2; // double

总结

本章我们一起初步学习了C++模板的相关知识，希望对大家了解C++模板有些许帮助，感谢大家阅读，如有不对欢迎纠正！🎠🎠🎠

吾与C
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
清晰的c++模板初阶学习博客，速来学
m0_67530233的博客
10-25 135
c++模板的初步学习
C++模板初阶
分享学习的知识，记录我的技术成长道路
03-13 963
在书写函数或类时，我们可能遇到这样的问题，明明结构一模一样但是只由于某个参数的类型不同就需要重新写函数，或者构建重载函数，重新书写类就更加麻烦了，并且使程序显得冗长，本文将介绍C++中的模板，从而解决相似函数重复书写问题。
C++之模板初阶
An_Mo的博客
09-23 246
一、泛型编程 泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础 模板：告诉编译器一个模子，让编译器根据不同类型利用该模子生成代码 模板分为：函数模板和类模板 二、 函数模板 1、函数模板概念 函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。 2、函数模板格式 template<typename T1, typename T2,…,typename Tn> 返回值类型 函数名(参数列表){} templ
模板初阶C++
2302_80873119的博客
02-21 877
模板初阶
由浅入深学习C++模板
11-21
模板练习 ├─Macro1 │ └─res ├─Macro2 ...└─模板学习 ├─初学模板(中1) ├─初学模板(中2) ├─初学模板(中3) ├─深学模板 1 ├─深学模板 2 ├─深学模板 3 ├─深学模板 4 └─深学模板
深入学习与实践C++模板编程 值得学习
04-11
C++模板是C++语言中的一个强大特性，它允许程序员创建泛型代码，即能够处理多种数据类型的代码。...深入学习和实践C++模板编程，无论是对初学者还是经验丰富的开发者，都能够进一步提升编程效率和代码质量。
c++类模板学习指南
04-02
有助于你深入地学习，理解c++类模板相关技术。由简单到复杂逐渐深入学习。
C++模板元编程
01-06
C++模板元编程
c++模板详细描述
01-05
c++模板详细描述
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1114
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1116
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 959
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 305
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 405
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 245
C++笔记3：基类指针delete子类对象的内存泄漏问题
C语言-栈和队列
m0_73605503的博客
07-22 1143
欢迎来到HanLop博客的C语言数据结构初阶系列。在之前的文章中，我们详细介绍了链表及其操作方法。在本篇文章中，我们将深入探讨栈和队列这两种常见的数据结构。栈和队列虽然都是线性数据结构，但它们在数据的存取方式上有着显著的区别。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。通过理解和掌握这两种数据结构，您将能更有效地管理数据，并为后续更复杂的数据结构和算法的学习打下坚实的基础。让我们一起开始探
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
热门推荐
面试高手的博客
07-21 3万+
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
C语言 打印菱形的程序（Program to print the Diamond Shape）
最新发布
csdn_aspnet的专栏
07-22 1923
O(n*n)，因为我们正在遍历网格的行和列来打印空格 ' '和星号 '*'。给定一个数字n ，编写一个程序来打印一个有2n行的菱形。O(1)，不使用额外空间。
C++模板入门与学习概览
"C++学习笔记，模板的引入，面向对象程序设计，C与C++的关系" 在C++编程中，模板是一种强大的工具，允许我们创建泛化的函数和类，能够处理不同类型的参数。模板的引入是为了更好地管理和复用代码，避免了因处理不同...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值