[C++]模版初阶

---

引言

C++为什么要引入模版？

当我们想用一个函数完成多个类型参数的操作时，发现每次都要重新再写一个函数再使用，对于重载的函数虽然可以使用，但是每次用新的类型都需要再去重载一次函数**。**
例如实现交换的函数：

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;
}
·····

缺点：

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

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

于是在C++中引入了模版的概念.

函数模版

类似于实现一种类型功能的函数所使用的模具。

函数模板格式

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

示例：

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

函数模板的原理

函数的内容并不是由写的函数模板部分来进行实现，而是编译器通过传入的实参类型进行推演生成对应类型的函数，然后调用对应类型的函数进行实现功能（对T进行替换）。

函数模板的实例化

template<typename T>
// 加const是因为下面传参会产生临时变量，临时变量具有常性
T Add(const T& left, const T& right)
{
	return left + right;
}

int main()
{
	int a = 10;
	int b = 90;
	double c = 1;

	cout << Add(a, c) << endl;

	return 0;
}

如上述代码，当在使用函数模板时传入的两个参数是两种不同类型的变量，而在使用的函数模板中链各个形参位置都是同一个T，这样的话编译器就无法确定到底是使用a的int还是c的double（报错）。所以在该种情况下应该使用函数模板的实例化。（用户也可以自己进行类型强制转换Add(a, (int)d); ）

下面是进行修改后的代码，实例化格式也如下：

// 显式实例化：在函数名后的<>中指定模板参数的实际类型
cout << Add<int>(a, c) << endl;

模板参数的匹配原则

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

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

当用两种类型进行使用就会调用模板函数。

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

在C++中，当考虑函数重载和类型转换时，非模板函数相比模板函数有一个特点，即非模板函数可以利用C++的隐式类型转换规则（也称为标准转换序列），而模板函数则不会自动考虑这些转换，除非显式实例化或通过其他方式明确指定。

具体来说：

• 非模板函数：如果有一个非模板函数，且传入的实参类型可以通过隐式转换匹配到该函数的形参类型，那么这个转换会被自动应用，允许调用该函数。例如，如果你有一个接受int参数的函数，你也可以传递一个char或short类型的值，因为这些类型可以隐式转换为int。
• 模板函数：对于模板函数，编译器不会自动尝试通过类型转换来匹配一个特定的实例化版本。如果直接调用模板函数并传入参数，编译器会严格检查参数类型是否可以直接匹配模板参数，而不会自动进行如整型提升或用户定义的转换等。这意味着，如果没有显式提供模板参数或没有其他上下文帮助编译器推断出正确的类型，仅依赖于隐式类型转换的调用可能不会成功。

但如果有多个模版参数的话，模板函数就会自动生成相对应的函数进行使用。当然如果通过显式模板实参或者其它上下文（如函数参数的类型推导）使得编译器能够明确地实例化模板，那么相应的类型转换规则（包括用户自定义转换）仍然会在实例化后的函数调用中生效。

类模版

定义格式

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

定义示例

// 类模板
template<class T>
class Stack
{
public:
	Stack(size_t capacity = 3);

	void Push(const T& data);

	// 其他方法...

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

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

例如用模版定义一个栈，现在需要将代码量比较大的成员函数放在类外声明，格式如下：

template<class T>
Stack<T>::Stack(size_t capacity)
{
	_array = new T[capacity];

	_capacity = capacity;
	_size = 0;
}

在类模板中，当你在类定义之外（类外）声明或定义成员函数时，需要使用模板语法来指定模板参数，这是因为成员函数实际上是模板类的成员，它们的实现依赖于类模板的类型参数。所以，正确的语法格式是先指明模板参数列表，然后是类名（包括模板参数），接着是成员函数的名称和其他参数列表。

• template 声明这是一个模板函数定义，T 是模板参数，它必须与Stack类模板中的参数类型相匹配。
• Stack:: 表示这是类Stack的一个成员函数。由于Stack是一个模板类，所以在类名后面紧跟模板参数列表，以明确指出我们正在定义的是模板类Stack的成员函数。
• 接下来是构造函数的名称Stack及其参数列表(size_t capacity)。

类模版的实例化

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

int main()
{
	Stack<int> s1;    // int
	Stack<double> s2; // double
	Stack<char> s3;   // char

	return 0;
}

---