[C++知识库]【C++】模板

1. 函数模板

1.1 概念

建立一个通用模具，提高代码复用性。

1.2 特点

• 模板不可以直接使用
• 通用是有条件的

1.3 模板语法

template<typename T>

注：typename也可以换成class。

示例：
实现两个同类型数的交换。

// 声明一个模板
template<typename T>
void Swap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
// 调用模板
// 调用方法一：自动类型推导
Swap(a, b);
// 调用方法二：显式指定类型
Swap<int>(a, b);

1.4 模板注意事项

• 自动类型推导，必须推导出一致的数据类型才可以正常使用
• 模板必须要确定出T的数据类型才可以使用
• 创建函数模板使用typename和class都可以，类模板使用class
• 即使在函数体中没有使用T类型的参数，仍旧需要指定数据类型。如：

template<typename T>
void func()   // 模板参数没有使用T类型的数据
{
   cout << "func的调用" << endl;
}

int main()
{
   func<int>();    // 此时，任意数据类型都可以
}

1.5 模板实例

对字符数组和数字数组使用同一模板进行排序。

实验代码：

#include <iostream>

using namespace std;

template<typename T>
// 打印输出数组
void print(T arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}
template<typename T>
// 交换两个值
void Swap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}
template<typename T>
// 选择排序
void sort(T Array, int len)
{
   // 最值下标使用temp存储，初始化为0
	int low = 0, temp = 0, high = len - 1; // 确定上界和下界
	cout << "排序前：";
	print(Array, len);
	while (low < high)
	{
		for (int i = low; i <= high; ++i)
		{
			if (Array[temp] <= Array[i])  // 更新最大值下标
			{
				temp = i;
			}
		}
		Swap(Array[temp], Array[high]);
		temp = --high;    // 最大值找到后，上界前移
		for (int i = high; i >= low; --i)
		{
			if (Array[temp] >= Array[i])  // 更新最小值下标
			{
				temp = i;
			}
		}
		Swap(Array[temp], Array[low]);
		temp = ++low;     // 最小值找到后，下界后移
	}
	cout << "排序后：";
	print(Array, len);
}

// 主函数
int main()
{
	cout << "字符数组：" << endl;
	char Arraya[] = { 'k', 'c', 'l', 's', 'a', 'w', 's', 'a', 'b', 'c', 'f', 'z', 'a', 'k', 'l' };
	sort(Arraya, sizeof(Arraya) / sizeof(Arraya[0]));
	
	cout << "数字数组：" << endl;
	int Arrayb[] = { 'k', 'c', 'l', 's', 'a', 'w', 's', 'a', 'b', 'c', 'f', 'z', 'a', 'k', 'l' };
	sort(Arrayb, sizeof(Arrayb) / sizeof(Arrayb[0]));

	system("pause");
	return 0;
}

2. 普通函数和模板函数的关系

2.1 区别

• 普通函数调用时可以发生自动类型转换（即隐式类型转换）
• 模板函数调用时，如果使用自动类型推导， 不会发生隐式类型转换
• 如果使用显式指定类型方式，则可以发生隐式类型转换，如：

int add1(int a, int b)
{
   return a + b;
}
template<typename T>
T add2(int a, int b)
{
   return a + b;
}

void test()
{
   int a = 10;
   int b = 20;
   char c = 'c';

   add1(a, b);          // 运行成功
   add1(a, c);          // 运行成功

   add2(a, b);         // 运行成功
   add2(a, c);         // 运行失败，原因是自动类型推导不发生类型转换，导致无法推导出同一数据类型报错
   add2<int>(a, c);  // 运行成功
}

2.2 调用优先级

• 两者同时实现，优先调用普通函数
• 强制调用模板函数时，通过空模板参数列表来实现 函数名<>(参数列表)
• 模板函数可以发生重载
• 如果模板函数可以产生“更好的匹配”，则优先调用模板函数。即，如果普通函数定义的参数和传入参数的数据类型不同，会优先调用模板函数。
• 如果说提供了函数模板，就不要继续提供普通函数，否则容易出现二义性

3. 模板的局限性

对于有些特定的数据类型，需要使用特定的方式做特殊实现。例：

template<typename T>
bool Compare(T&a, T&b)	// 一般的数据类型
{
	// ...
}
template<> bool Compare(t&a, t&b)	// 特殊的数据类型t
{
	// ...
}

4. 类模板

语法格式：

template<class T> 
class CLASS
{
	// ...
}

4.1 类模板中成员函数创建的时机

• 普通类中的成员函数一开始就创建了
• 类模板中的成员函数在调用时才创建

4.2 类模板对象做函数参数

1. 指定传入的类型，直接显示对象的数据类型
2. 参数模板化，将对象中的参数变为模板进行传递
3. 整个类模板化，将这个对象模板化进行传递

5. 类模板和函数模板的区别

• 类模板没有自动类型推导的方式，所以只能使用显示指定类型方式
• 类模板在模板参数列表中可以有默认参数