C++学习记录——구 模板初阶

---

1、泛型编程和函数模板

泛型编程顾名思义，泛用性很高。之前C++可以用重载来对付同名函数，但还是麻烦，有一个类型的变量就得写一个类型的函数。C++对此创建了库这个概念，比如要用到交换函数，那么我们取库里的函数即可，并且不需要考虑类型。常见的函数都已经包括在头文件里，所以直接用就行。

template<class S>
void Swap(S& x, S& y)
{
	S tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 1, b = 2;
	Swap(a, b);

	float c = 1.1, d = 2.2;
	Swap(c, d);
	return 0;
}

这样就会很方便。但一个整形一个浮点型不能作为函数参数。

int和float类型两次调用的不是同一个函数。在汇编代码里，两者调用的函数地址不一样，栈帧也不一样。所以即使是同一个库里，调用的也不一样。它们调用的不是模板，调用的还是自己的，模板里只是编译器帮你集成了所有类型的函数，但代码量少，不需要程序员操心。模板会根据代码实例化出对应的函数代码，会把S换成相应的类型。模板相当于提供了蓝图，编译器填充了内容，然后程序员直接用即可。

1、函数模板的实例化

参数不同类型可以用强制类型转换来处理，但是精度会丢失。另一个方法就是显式实例化。

int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 1.1, d2 = 2.2;
	cout << Add<int>(a1, d2) << endl;
	cout << Add<double>(a1, d2) << endl;
	return 0;
}

这里就是让编译器不再自己去推演类型，而是根据代码找到对应的函数。

2、模板参数的匹配原则

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

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;
	int b = 2;
	Add(a, b);
}

如果参数类型是非模板函数的参数类型，那么就会调用非模板函数，反之则调用模板函数，这是自动的，我们也可以指定调用模板函数。

Add<int>(a, b);

这样就会调用模板函数了。编译器会选择更适配的那个函数，如果实在没有合适的，就会选择相对来讲更好的。

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

2、类模板

template<class T>
class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = new T[capacity];
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		delete[] _a;
		_capacity = _top = 0;
	}
private:
	T* _a;
	size_t _top;
	size_t _capacity;
};

int main()
{
	Stack<int> st1;
	Stack<double> st2;
	return 0;
}

函数模板可以推演类型，但是类模板必须要显式写出来。

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

在类外面使用类的成员函数时，之前是类::函数名，有了模板后，需要先声明一下模板，再去调用函数。

template<class T>
Stack<T>::Print();

类模板不可以声明与定义分离。可以都放在类里，也可以放入同一个文件里。

结束。