【C++】模版（一）

泛型编程、模版（一）：

1.泛型编程：

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

【思考】

原本的函数重载，我只是改了函数参数个数和参数类型，我们需要为不同的重载函数写同样的代码

❓我们可以将他们写在一起吗？

可以的，用泛型编程！template后面就写正常的函数就可以了

template<class T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 1, b = 2;
	Swap(a, b);
	return 0;
}

❓为什么不能直接函数重载，而要弄一个泛型编程呢？

• 就拿swap函数为例，当参数类型变为char类型，我们需要写一个重载函数，而当参数类型为int类型又要写一个重载函数。
• 代码的可维护性比较低，一个出错可能所有的重载均出错

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

如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件

(即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。

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

1.1调用泛型编程时，不同参数的地址是否一样？

template<class T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 1, b = 2;
	Swap(a, b);

	double c = 1.1, d = 1.2;
	Swap(c, d);
	return 0;
}

❓这两个swap函数是不是调用同一个函数呢？

显然，这两个函数的地址不一样，这两个并不是同一个函数

1.2泛型编程的底层原理：

编译器会帮我们实例化出代码，该有两份还是有两份，三份代码还是三份

---

2.模版：

模版分为两种：一种是函数模版，一种是类模板

2.1函数模版：

函数模板概念：

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

2.1.1函数模板的语法：

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

模版有多个参数

template<class x,class y>
void swap(x& a, y& b)
{
	;
}

❓template这里的class可以用什么替代？

可以用typename，但是不可以用struct替代（报错）

只要是模版中定义的参数，函数都可以使用

Swap这个函数库里面有写了一个函数模版

template<typename T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a = 1, b = 2;
	double c = 1.1, d = 1.2;
	cout<<Add(a, (int)d)<<endl;
	cout<<Add((double)a, d)<<endl;
	cout << Add<int>(a ,d) << endl;
	cout << Add<double>(a ,d) << endl;
	return 0;
}

❓ Swap(a, d);这个能不能编译通过？

答案是不可以的，编译器不能准确的推演类型，如何解决呢？

1.强制类型转换

2.显示实例化

当函数同时存在，他会调用哪一个呢？

显然，编译器回调我们写的

template<typename T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int Add(int left, int right)
{
	return left + right;
}
int main()
{
	int a = 1, b = 2;
	Add(a, b);
	return 0;
}

那如果我们想要调用模版怎么办？

Add(a, b);这样就可以了

2.2类模板：

2.2.1类模板的语法：

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

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;//int
	Stack<double> st2;//double
	return 0;
}

类模版中的函数如果要类外写，怎么写

// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
if(_pData)
delete[] _pData;
_size = _capacity = 0;
}

Stack st1;//int
Stack st2;//double
return 0;

}

类模版中的函数如果要类外写，怎么写

```cpp
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template 
Vector::~Vector()
{
if(_pData)
delete[] _pData;
_size = _capacity = 0;
}