C++模板

模板

有两大分类，函数模板和类模板
其核心思想就是将数据类型看作一个变量，可以在函数调用或者类构建时自由修改变量的数据类型

函数模板

基础使用

语法

template<class T>
void f(T a, T b)
{ 
    a = b;
}

两种调用方法

自动类型推导，必须推导出一致的数据类型T,才可以使用
	f(a,b);
模板必须要确定出T的数据类型，才可以使用
	f<int>(a,b);

与普通函数的区别

普通函数调用时可以发生自动类型转换（隐式类型转换）
	void func(int a){
		cout<<a;
	}
	void main(){
		func('c');//这样使用普通函数打印的是'c'的acsii码
	}
	
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
template<class T>
	void func(T a){
		cout<<T;
	}
	void main(){
		func('c');//这样使用自动推导打印的是'c'
	}
	
如果利用显示指定类型的方式，可以发生隐式类型转换
template<class T>
	void func(T a){
		cout<<T;
	}
	void main(){
		func<int>('c');//这样使用自动推导打印的是'c'的ascii码，与普通函数一样
	}
	

与普通函数之间的调用优先关系

先写好两个函数方便下面阅读
	void myPrint(int a, int b)
	{
		cout << "调用的普通函数" << endl;
	}
	
	template<typename T>
	void myPrint(T a, T b) 
	{ 
		cout << "调用的模板" << endl;
	}

	template<typename T>
	void myPrint(T a, T b,T c) 
	{ 
		cout << "调用的模板" << endl;
	}
调用规则如下：
	函数模板也可以发生重载
		//如上面前两个函数就是重载函数
	如果函数模板和普通函数都可以实现，优先调用普通函数
		myPrint(10,10);//优先调用普通函数
	可以通过空模板参数列表来强制调用函数模板
		myPrint<>(10,10);//强制调用函数模板
	如果函数模板可以产生更好的匹配,优先调用函数模板
		myPrint(10,10,10);//优先调用最后一个函数模板

函数模板的局限性以及解决方法

局限

函数模板的调用并不是万能的，对于类或者其余自定义类型，函数模板就心有余而力不足了

解决方法：具体化，这样自动选择类型的时候就会优先匹配写好的参数类型

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};

//具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//具体化优先于常规模板
template<> bool myCompare(Person &p1, Person &p2)
{
	if ( p1.m_Name  == p2.m_Name && p1.m_Age == p2.m_Age)
	{
		return true;
	}
	else
	{
		return false;
	}
}

类模板

语法

template<class NameType, class AgeType> 
class Person
{
public:
	NameType mName;
	AgeType mAge;
};

使用

基本与上面的函数模板相同

类模板作为参数传入函数

类模板结构
template<class NameType, class AgeType = int> 
class Person
{
public:
	NameType mName;
	AgeType mAge;
};

指定传入的类型 — 直接显示对象的数据类型
void printPerson1(Person<string, int> &p) {
	这里是指定了类的参数类型
}
调用
void test01()
{
	Person <string, int >p("孙悟空", 100);
	printPerson1(p);
}

参数模板化 — 将对象中的参数变为模板进行传递
template <class T1, class T2>
void printPerson2(Person<T1, T2>&p){
	这里是把类的两个参数类型，二次作为类模板参数T1、T2
}
调用
void test02()
{
	Person <string, int >p("孙悟空", 100);
	printPerson1(p);//这里是进行了自动推导类型
	printPerson1<string,int>(p);//这个和上面的方法一样
}

整个类模板化 — 将这个对象类型 模板化进行传递
template<class T>
void printPerson3(T & p){
	这里是把整个类作为类模板参数
}
调用
void test03()
{
	Person <string, int >p("唐僧", 30);
	printPerson3(p);
}

注意事项

类模板使用

类模板没有自动类型推导的使用方式
	//Person *me = new Person("我"，18);//无法运行
	Person *me = new Person<string,int>("我"，18);//必须指定参数类型
	
类模板在模板参数列表中可以有默认参数
	template<class NameType = string, class AgeType = int> 
	class Person
	{
	public:
		NameType mName;
		AgeType mAge;
	};

类模板成员函数创建

类模板中成员函数和普通类中成员函数创建时机是有区别的：
	普通类中的成员函数一开始就可以创建
	类模板中的成员函数在调用时才创建

模板的一般应用就到这，以下是一些相关类模板的相关链接

1、类模板与继承
2、类模板成员函数类外实现
3、类模板的分文件编写