c++的模板

什么是模板

拥有一个模具(函数的部分实现除去了类型),我们通过注入不同颜色的材料(类型int,double等等),我们就可以打印出功能相似,但是颜色不同的工具。

函数模板

void Swap(double& x , double& y)
{
    double temp = x;
    x = y;
    y = temp;
} 
void Swap(int& x , int& y)
{
    int temp = x;
    x = y;
    y = temp;
}
//我们发现这两个函数实现的功能是类型的交换，但是由于数据类型的不同，不得不进行重载，加大了代码的冗余度。

但是我们使用了模板后会减少很多

template <typename T>
void Swap(T&x , T&y)
{
    T temp = x;
    x = y;
    y = temp;
}
int main(void)
{
    int x = 6;
	int y = 9;
	Swap<int>(x,y);
}

（const引用是万能引用）

我们知道如果传入的参数是一个自定义类型的参数，那么我们就需要对参数进行拷贝构造，这显然降低了我们代码的效率，所以我们可以选择传引用，来解决这个问题。

但是这个存在一定的问题

template <typename T>
void Swap(T&x , T&y)
{
    T temp = x;
    x = y;
    y = temp;
}
int main(void)
{
 
	Swap<int>(6,9);
    //在这里会出现一个错误,6和9是一个常量,常量是不允许被修改的,因此当我们引用常量的时候需要对范围进行一个限制,
    void Swap(const T&x ,const T&y)
}

类模板

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
template <class T>
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack(size_t capacity = 3)" << endl;

		_a = (T*)malloc(sizeof(T) * capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败!!!");
		}

		_capacity = capacity;
		_top = 0;
	}
	Stack(Stack& dd)
	{
		cout << "Stack(size_t capacity = 3)231" << endl;

		_a = (T*)malloc(sizeof(T) * dd._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败!!!");
		}
		memcpy(_a, dd._a, sizeof(T) * dd._top);
		_top = dd._top;
		_capacity = dd._capacity;
	}
 template <typename T>
class Kueue {
private:
	T s1;
	T s2;
};
    int main(void)
    {
    Stack<int> str;
	Kueue<Stack<int>> q;

    }