C++模板初识

一、函数模板

1. 函数模板

1. 模板函数：在函数调用点，编译器用用户指定的类型，从原模板实例化一份函数代码出来。

2. 模板的实参推演 => 可以根据用户传入的实参的类型，来推导出模板类型参数的具体类型。

3. 函数模板是不进行编译的，因为类型还不知道；
   模板的实例化 - 函数调用点进行实例化模板函数才是要被编译器所编译的。

2. 函数模板、模板的特例化、非模板函数的重载关系

不属于重载关系，属于共存关系

3. 外部调用

模板代码是不能在一个文件中定义的。在另外一个文件中使用的模板代码调用之前，一定要看到模板定义的地方，这样的话，模板才能够进行正常的实例化，产生能够被编译器编译的代码。

	// 告诉编译器，进行指定类型的模板实例化
	template bool compare<int>(int, int);
	template bool compare<double>(double, double);

所以，模板代码都是放在头文件当中的，然后在源文件当中直接进行#include包含。

4. 模板的非类型参数

必须是整数类型（整数或地址/引用都可以），都是常量，只能使用，而不能修改。

	template<typename T int SIZE>
	void sort(T *arr) {
   
   
		for(int i = 0; i < SIZE - 1; ++i)
			for(int j = 0; j < SIZE - 1 - i; ++j)
				if(arr[j] > arr[j + 1]) {
   
   
					int tmp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
				}
	}
	
	int arr[] = {
   
    12, 5, 7, 89, 32, 21, 35 };
	const int size = sizeof(arr) / sizeof(arr[0]);
	sort<int, size>(arr);

5. 代码示例

#include <iostream>
using namespace std;

// 函数模板 
template<typename T> // 定义一个模板参数列表
bool compare(T a, T b) {
   
   
	cout << "template compare" << endl;
	return a > b;
}

// 模板特例化 - 针对compare函数模板，提供const char*类型的特例化版本
template<>
bool compare<const char*>(const char* a, const char* b) {
   
   
	cout << "compare<const char*>" << endl; 
	return strcmp(a, b) > 0;
}

// 非模板函数 - 普通函数
bool compare(const char* a, const char* b) {
   
   
	cout << "normal compare" << endl;
	return strcmp(a, b) > 0;
}

int main() {
   
   
	compare<int>(10, 20);
	compare(100, 20);
	compare("100", "20");
	compare<const char*>("100", "20");

	return 0;
}

输出结果：

template compare
template compare
normal compare
compare<const char*>

二、类模板

1. 以顺序栈为例

#include <iostream>
using namespace std;

// 类模板 -> 实例化 -> 模板类
template<typename T>
class SeqStack {
   
    // 模板名称 + 类型参数列表 = 类名称
public:
	// 构造和析构函数名不用加<T>，其它出现模板的地方都加上类型参数列表
	SeqStack(int size = 10)
		: _pstack(new T[size])
		, _top(0)
		, _size(size)
	{
   
   }

	~SeqStack() {
   
   
		delete[]_pstack;
		_pstack = nullptr;
	}

	SeqStack(const SeqStack<T>& stack)
		: _top(stack._top)
		, _size(stack._size)
	{
   
   
		_pstack = new T[_size];
		// 不要用memory进行拷贝
		for (int i = 0; i < _top; ++i) {
   
   
			_pstack[i] = stack._pstack[i];
		}
	}

	SeqStack<T>& operator=(const SeqStack<T>& stack) {
   
   
		if (this == &stack) {
   
   
			return *this;
		}

		delete[]_pstack;
		_top = stack._top;
		_size = stack._size;
		_pstack = new T[_size];
		// 不要用memory进行拷贝
		for (int i = 0; i < _top; ++i) {
   
   
			_pstack