【C++】模板(初级)

最新推荐文章于 2024-06-30 20:23:11 发布

Brant_zero2022

最新推荐文章于 2024-06-30 20:23:11 发布

阅读量435

点赞数 1

分类专栏： C++ 文章标签： c++ 开发语言后端服务器

本文链接：https://blog.csdn.net/Brant_zero/article/details/126575738

版权

C++ 专栏收录该内容

40 篇文章 6 订阅

订阅专栏

一、泛型编程

在以下这种场景中便会出现泛型编程(实现一个通用的交换函数)：

在C++中有函数重载功能，如果我们要实现这以上三组数据的交换，明显要实现 3 组 swap 函数，

使用函数重载虽然可以实现，但是有以下几个不好的地方：

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

这样重复而赘余的代码是很不合理的，所以C++引入了模板，这泛型编程。

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

二、函数模板

2.1 函数模板概念

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

2.2 函数模板格式

为了实现上面 swap 函数，所以我们可以定义一以下函数模板。

注意： typename 是用来定义模板参数的关键字，也可以使用 class (但不能使用 struct 代替 class)

2.3 函数模板的原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的磨具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

在编译器编译阶段，对于模板函数的的使用，编译器需要根据传入的实参类型来推演生成的对应类型的函数以供调用。

比如：当用 double 类型使用函数模板时，编译器通过对实参的推演，将 T 确定为 double 类型，然后产生一份专门处理 double 类型的代码，对于字符类型也是如此。

2.4 函数模板的实例化

用不同类型的参数使用函数模板时，成为函数模板的实例化。

模板参数实例化分为：

隐式实例化：让编译器根据实参推演模板参数的实际类型。
显示实例化：在函数名后的 < >中指定模板那参数的实际类型。

隐式实例化:

现在引申出一个问题：如果我们传入的参数类型不相同，那应该怎么办呢？

例如，我使用上面的 Add 函数将一个 int 型数据和 double 数据相加，那会产生什么结果呢？

如果出现了上面这种情况，编译器就会报错，就好比你的左手和右手，两个相同的指令，编译器就无法分辨了。

这时，我们就可以使用显示实例化来解决，将类型直接指定为 int 。

方法一：显示实例化:

方法二：上面这种场景，还可以使用强制类型转换，但是效果相同的。

方法三：书写一个使用了两个模板参数的函数。

使用方法三，就又会引申出一个问题，这样，再调用 Add 函数的时候，是会调用一个模板的呢，还是两个不同的模板参数的呢？

如果两个类型相同，就会去调用一个模板参数的函数，如果两个参数类型不同，就会调用两个模板参数的模板函数。

2.5模板参数的匹配原则

1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

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

三、类模板

3.1 引入

以前我们在 C 语言中使用 typedef 模仿泛型编程，但是这种方式远远不能叫做泛型编程。

因为他还是在针对具体的类型来进行的。例如，我们想让一个栈的数据结构，既能存放 char 型数据，也能存放 int 型数据，这时， typedef 就无法解决这样的问题，只能通过书写两套栈来实现刚刚提到的场景。

学习了类模板之后，我们就可以这样来实现栈。

3.2 类模板实现Stack

template <class T>
class Stack
{
public:
	Stack(int capacity=4)
		:_a(nullptr)
		,_top(0)
		,_capacity(0)
	{
		//防止传入参数中 capacity为0 ，则不扩容直接结束
		if (capacity >0)
		{
			_a = new T[capacity];
			_capacity = capacity;
			_top = 0;
		}
	}

	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_capacity = _top = 0;
	}

	void CheckCapacity()
	{
		if (_capacity == _top)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			//这里不做检查，检测的话用 try catch 即可
			T* temp = new T[newcapacity];
			//如果原来数组有数据，将数据拷贝过来
			if (_a)
			{
				memcpy(temp, _a, sizeof(T) * _top);
				delete[] _a;
			}
			_a = temp;
			_capacity = newcapacity;
		}
	}

	void Push(const T& val)
	{
		CheckCapacity();
		_a[_top] = val;
		_top++;
	}

	void Pop()
	{
		assert(_top > 0);
		--_top;
	}

	 T& Top()
	{
		assert(_top > 0);
		return _a[_top-1];
	}
	 bool Empty()
	 {
		 return _top == 0;
	 }
private:
	T* _a;
	size_t _capacity ;
	size_t _top;
};


int main()
{
	Stack<int>st1;
	st1.Push(1);
	st1.Push(2);
	st1.Push(3);
	st1.Push(4);
	st1.Push(5);
	st1.Push(6);

	while (!st1.Empty())
	{
		cout << st1.Top() << endl;
		st1.Pop();
	}
	return 0;
}