【C++入门】模版初阶(泛型编程)

1.泛型编程

让我们思考一个小问题：如何实现一个通用的交换函数呢？

在解决这个问题之前，我们希望交换两个变量，这两个变量是整型，或是浮点型，又或是其它内置类型，然后它们的交换都可以用一个函数完成。
那在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;
}

使用函数重载虽然可以实现，但是有一下几个不好的地方:

重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数

代码的可维护性比较低，一个出错可能所有的重载均出错

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢?

C++引入了泛型编程，就可以解决这个问题。

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

借助模版我们便可解决上述问题。

2.函数模版

2.1函数模版的概念

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

2.2函数模版的使用

函数模版格式：

template<typename T1, typename T2,…,typename Tn>
返回值类型函数名(参数列表){ }
注意: typename是用来定义模板参数关键字，也可以使用class(切记:不能使用struct代替class)

让我们回到上面那个问题有了模版就可以这样解决：

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

这里的T是我们定义的模板的类型名称，我们调用Swap时，传的参数是什么类型，T就会被替换成对应的类型，然后Swap函数就对该类型的参数进行相应的处理。

这样上述问题代码可以这样写：

那么这里有一个小问题：我们上面的Swap(a, b)和Swap(c, d)调用的是同一个函数吗？

答案是否。这里我们通过反汇编看一下：

这里两个函数的地址是不一样的，并不是一个函数。

2.3函数模版的原理

大家都知道，瓦特改良蒸汽机，人类开始了工业革命，解放了生产力。机器生
产淘汰掉了很多手工产品。本质是什么，重复的工作交给了机器去完成。有人给出了论调:懒人创造世界。

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

那么编译器是怎么做的呢？

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

2.4函数模版的实例化

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

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

我们来看一个例子：

template<class T>
T Add(const T& left, const T& right)
{
    
    
	return left + right;
}
int main()
{
    
    
	int a1 = 10, a2 = 20;
	double d1 = 10.0, d2 = 20.0;

	cout << Add(a1, a2) << endl;
    cout << Add(d1, d2) << endl;
	return 0;
}

我们先来看一下运行结果：

那下面我们这样呢？

这里程序报错的原因是：
这时候函数模板在推演实例化的时候会出现歧义：
该语句不能通过编译，因为在编译期间，该函数模板实例化时，需要推演其实参类型。这时通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错。
注意：在模板中，编译器一般不会进行类型转换操作。

面对这种问题我们先提出一种解决方法：

我们可以自己进行强制类型转换：

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

对于上述问题我们还能通过这一方法解决：

2.5 模板参数的匹配原则

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

// 专门处理int的加法函数
int Add(int left, int right)
{
    
    
	return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
    
    
	return left + right;
}
int main()
{
    
    
    int a = 1, b = 2;
    Add(a,b);
    return 0;
}

这里程序会调用哪个呢？我们调试看一下：

我们通过调式可以看到它调的是第一个。
为什么会调第一个，因为编译器在这个地方也会看调用哪一个成本会更低一点，第一个可以直接调用，但第二个还需要用模板实例化之后才能调用。
所以在这里编译器选择了第一个。

当然这里我们可以通过显示实例化去调用模版函数生成的：

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

3.类模版

3.1类模版的定义格式

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

我们来看一个例子：

之前我们如果想写一个栈会这样写：

typedef int DataType;
class Stack
{
    
    
public:
	//构造函数
	Stack(size_t capacity = 4)
	{
    
    
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
    
    
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
    
    
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	// 其他方法...
private:
	DataType* _array;
	int _capacity;
	int _size;
};

这样写如果我们在main函数里定义了2个或者多个栈，想让它们分别存储不同类型的数据，是不是很难做到因为上述代码中数据是int类型，如果我们希望数据是其他类型是不是要再写一个栈。

但是学过模版之后我们便可以这样解决：

3.2类模版的实例化

template<class T>
class Stack
{
    
    
public:
	Stack(int capaicty = 4)
	{
    
    
		_a = new T[capaicty];
		_top = 0;
		_capacity = capaicty;
	}

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

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

要注意的是：
1. 类模板实例化与函数模板实例化有些不同，类模板实例化只能显式实例化，即需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可。
2. 类模板不是真正的类，其实例化的结果才是真正的类。

函数模板实例化可以根据参数类型去推演模板参数的类型，但是我们拿一个类去创建对象，就比如当前的栈，不会直接传数据类型是什么，所以要显式实例化：

注意：这里Stack是类名，Stack<int>才是类型
类模板中成员函数放在类外进行定义时，需要加模板参数列表

我们定义一个类可能习惯头文件和源文件分开来，那普通类这样是没有什么问题的
但是呢，类模板不行，类模板如果这样，会链接错误的，至于原因呢，我们后面到模板进阶的时候会讲，大家先了解一下。