C++六（模板初阶）

#include<iostream>

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

//模板：1.函数模板  2.类模板

//函数模板格式
//template<typename T1, typename T2, ......, typename Tn>  //typename  可以换成class
//返回值类型 函数名(参数列表) {}


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

int main()
{
	int a = 10;
	int b = 20;
	Swap(a, b);
	double c = 2.3;
	double d = 4.5;
	Swap(c, d);

	float e = 2.1, f = 4.3;
	Swap(e, f);

	//Swap(1.2, 3.4);   //为什么报错?

	return 0;
}
#endif
//用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例 化。

#if 0
template<class T>
T Add(const T& l, const T& r)
{
	return l + r;
}

//如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

int main()
{
	int a = 10;
	int b = 20;    //auto b = 20;

	//隐式实例化：让编译器根据实参推演模板参数的实际类型
	Add(a, b);

	Add(3.2, 2.3);  //这里为什么又不报错？

	float c = 9.1;
	float f = 10.9;
	Add(c, f);

	Add(c, (float)b);  //强制类型转换，还可以用显示实例化

	//显示实例化
	Add<int>(c, f);
	Add<int>(a, f);
	Add<double>(a, b);
	Add<double>(c, a);

	return 0;
}
#endif

//一个非模板函数可以和一个同名的函数模板同时存在，
//而且该函数模板还可以被实例化为这个非模板函 数
#if 0
int Add(const int l, const int r)
{
	return l + r;
}

template<typename T>
T Add(const T L, const T R)
//T Add(T L, T R)
{
	return L + R;
}

int main()
{
	std::cout << Add(1, 2) << std::endl; //与非模板函数匹配， 编译器不需要特化
	std::cout << Add<int>(1, 2); //调用编译器特化的Add版本

	return 0;
}
#endif 

// 对于非模板函数和同名函数模板，如果其他条件都相同，
//在调动时会优先调用非模板函数而不会从该模 板产生出一个实例。
//如果模板可以产生一个具有更好匹配的函数， 那么将选择模板。
#if 0
int Add(const int left, const int right)
{
	return left + right;
}

template<class T>
T Add(const T left, const T right)
{
	return left + right;
}

int main()
{
	Add(1, 2);  // 与非函数模板类型完全匹配，不需要函数模板实例化 
	Add(1, 2.0);    // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数 

	return 0;
}
#endif 

//类模板

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

//动态顺序表
#include<assert.h>
template<typename T>
class Vector
{
public:
	Vector(size_t capacity = 10)
		:_pData(new T[capacity])
		,_size(0)
		,_capacity(capacity)
	{}

	~Vector(); //在类内声明， 在类外定义

	void PushBcak(const T& data)
	{
		//_CheckCapacity(); //先检查容量
		_pData[_size++] = data;
	}

	void PopBack()
	{
		--_size;
	}

	size_t Size()
	{
		return _size;
	}

	T& operator[](size_t pos)
	{
		assert(pos < _size);
		return _pData[pos];
	}

private:
	T* _pData;
	size_t _size;
	size_t _capacity;
};

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

//注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具

//类模板的实例化
//Vcetor 是类名， Vector<int> 才是类型
using std::cout; 
int main()
{
	Vector<int> s1;
	s1.PushBcak(1);
	s1.PushBcak(2);
	s1.PushBcak(3);
	s1.PushBcak(4);

	Vector<double> s2;
	s2.PushBcak(0.1);
	s2.PushBcak(0.2);
	s2.PushBcak(0.3);
	s2.PushBcak(0.4);

	for (size_t i = 0; i < s1.Size(); ++i)
	{
		cout << s1[i] << " ";
	}

	cout << std::endl;

	for (size_t i = 0; i < s2.Size(); ++i)
	{
		cout << s2[i] << " ";
	}

	return 0;
}