C++模板初阶

什么是模板？

C++中的模板（Templates）是一种泛型编程工具，它允许函数或类操作于任意类型而无需在编写代码时指定具体类型。模板使得代码在处理不同类型时具有更高的重用性和灵活性。

模板提供了一种机制，通过在代码中使用类型参数（type parameters），使得函数和类能够适用于任意类型。模板分为函数模板和类模板两种：

1. 函数模板：定义一个通用函数，其操作适用于不同的数据类型。
2. 类模板：定义一个通用类，其成员和方法可以处理多种数据类型。

模板的具体类型在实例化（Instantiation）时才确定，即在模板被使用时，编译器根据实际传入的类型生成对应的函数或类的具体实现。

为什么需要模板？

当实现一个通用的交换函数时：

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;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

// ...

int main() {
    int x = 5, y = 10;
    Swap(x, y);  // 生成用于int类型的swap函数
    cout << "x = " << x << ", y = " << y << endl;

    double a = 1.1, b = 2.2;
    Swap(a, b);  // 生成用于double类型的swap函数
    cout << "a = " << a << ", b = " << b << endl;
    return 0;
}

使用函数重载虽然可以实现，但是有一下几个不好的地方：
1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函
数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错
那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

函数模板

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

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

// 模版 - 泛型编程
// typename后面类型名字T是随便取的，Ty，K，V，一般大写字母或单词首字母大写
// T代表一个模版（虚拟）类型
// template<typename T> // 模版参数（模版类型） -- 类似函数参数（参数对象）
// template<class T> // typename和class在大部分情况下没有区别
template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

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

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

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

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

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

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

template<class 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()
{

	int a1 = 10, a2 = 20;
	double d1 = 10.0, d2 = 20.0; 
	Add(a1, a2);
	Add(d1, d2); 

	// Add(1.1, 2); // 推演实例化报错

	//该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
	//	通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
	// 编译器无法确定此处到底该将T确定为int 或者 double类型而报错
	//	注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅

	// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化

	// 推演实例化矛盾，报错
	// Add(1.1, 2);

	// 编译器自动推演，隐式实例化
	Add(a1, (int)d1);

	// 显式实例化
	Add<double>(1.1, 2);

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

	return 0;
}

模板参数的匹配原则

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

// 专门处理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版本
}

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

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

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

类模板

类模板的定义格式：

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

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

// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;

// 类模板
typedef int STDataType; // 不属于泛型

class Stack
{
private:
	STDataType* _a;
	int top;
	int capacity;
};

int main()
{
	// 解决不了一个类中st1存char，st2存int
	Stack st1; // char
	Stack st2; // int

	return 0;
}

使用栈演示：

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

	}

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

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

			_a = tmp;
			_capacity - newCapacity;
		}
		// 放数据
		_a[_top] = x;
		++_top;
	}

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

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

	// 引用返回是可以被修改的，所以加const
	const T& Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}

private:
	// 跟上面不加:_a等等的本质是一样的
	//T* _a = nullptr;
	//size_t _top = 0
	//size_t _capacity = 0;
	T* _a;
	size_t _top;
	size_t _capacity;
};

// 模版不支持分离编译。声明放在.h 定义放在.cpp，
// 但是在同一个文件内可以声明和定义分离的


int main()
{
	// 规范写，抛异常
	try 
	{
		// 类模板都是显示实例化
		// 虽然它们用了同一个类模板，但是它们不是一个类型
		//Stack<int> st1;
		//Stack<char> st2;

		 知道要存100个数据，避免插入时扩容消耗
		//Stack<int> st3(100);
		//Stack<int> st3(0);

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

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



 	return 0;
}