模板的知识介绍

1、模板 — 泛型编程(广泛类型的编程)

//泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
//模板分为两类：函数模板和类模板

2、函数模板

2.1 函数模板概念

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

2.2 函数模板格式

// template<typename T1,typename T2, .....,typename Tn>  【typename只可以换成class】【一般只有一个模板参数】

//template<typename T> //模板参数（模板类型）---类似函数参数（参数对象）
//typename后面类型名字T是随便取的，Ty\K\V ,一般是大写字母或单词首字母大写
// T代表是一个模板类型（虚拟类型）


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

int main()
{
	int i = 1, j = 2;
	double x = 1.1, y = 2.2;
	char m = 'A'; char n = 'B';
	
	Swap(i,j);
	Swap(x,y);
	Swap(m,n);

	return 0;
}

// 函数模板的实例化: 根据实参的类型 产生 相应类型的函数。

2.3 C++库里面有swap函数，可以直接用

int main()
{
	int i = 1, j = 2;
	double x = 1.1, y = 2.2;
	char m = 'A'; char n = 'B';
	
	swap(i,j);
	swap(x,y);
	swap(m,n);

	return 0;
}

2.4 函数模板的实例化

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


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

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


int main()
{
	Add(1,2);
	//Add(1.1,2); //推演实例化矛盾，报错
	
	//(1)隐式示例化解决（编译器自动推演）
	cout<< Add(1, 2) <<endl;
	cout << Add((int)1.1, 2) << endl;
	cout << Add(1.1, (double)2) << endl;

	//(2)显示实例化
	cout << Add<int>(1.1, 2) << endl;
	cout << Add<double>(1.1, 2) << endl;

	//必须显示实例化才能调用
	Func<A>(10);

	return 0;
}

3、类模板

template<typename T>
class Stack
{
public:
	//构造函数
	Stack(size_t capacity = 4)
		:_a(nullptr)
		, _top(0)
		, _capacity(0)
	{
		if (capacity > 0)
		{
			_a = new T[capacity];
			_capacity = capacity;
			_top = 0;
		}
	}

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

	void Push(const T& x) // 插入的是T类型的数据
	{
		if (_top == _capacity)
		{
			size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
			//1、开新空间
			T* tmp = new T[newCapacity];
			if (_a)
			{
				//2、拷贝数据
				memcpy(tmp, _a, sizeof(T) * _top);
				//3、释放旧空间
				delete[] _a;
			}

			_a = tmp;
			_capacity = newCapacity;
		}

		//插入数值
		_a[_top] = x;
		++_top;
	}

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

	bool Empty()
	{
		return _top == 0;
	}

	const T& Top()
	{
		assert(_top > 0);
		return _a[_top - 1]; //数据放在堆区的，Top的栈帧销毁了之后，仍然存在
	}


private:
	T* _a;
	size_t _top;
	size_t _capacity;
};

//模板不支持分离编译；即：声明放在.h , 定义放在 .cpp 
//模板在同一个文件中，声明和定义是可以分离的。

int main()
{
	try
	{
		//类模板都是显示实例化
		//虽然它们用了一个类模板，但是Stack<int>, Stack<char> 是两个类
		Stack<int> st1;
		st1.Push(1);
		st1.Push(2);
		st1.Push(3);
		st1.Push(4);
		st1.Push(5);

		//栈顶的数据不允许修改，这儿试验一下而已
		/*st1.Top()++;
		st1.Top() *= 2;*/


		while (!st1.Empty())
		{
			cout << st1.Top() << " ";
			st1.Pop();
		}
		cout << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}