C++泛型编程：模板(2)---具体化模板、类模板

模板的局限性：

• 模板的通用性不是万能的；
  
  （数组无法直接进行赋值操作；）
  
  C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板；

class Person {
public:
	Person(string name,int age) {
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
};
//普通函数模板
template<typename T>
bool compare(T& a,T& b) {
	if (a == b) {
		return true;
	}else {
		return false;
	}
}
//利用具体化Person的版本实现代码，具体化优先调用
//具体化，显示具体化的原型需要以template<>开头，并通过名称指出类型；
//具体化优先于常规模板
template<> bool compare(Person& p1, Person& p2) {
	if (p1.m_age==p2.m_age&&p1.m_name==p2.m_name) {
		return true;
	}
	else {
		return false;
	}
}
int main() {
	int a = 10, b = 10;
	//内置数据类型可以直接使用通用的函数模板
	if (compare(a, b)) {
		cout << "a与b相等！" << endl;
	}
	else {
		cout << "a与b不相等！" << endl;
	}
	Person p1("张三", 18);
	Person p2("李四", 18);
	//自定义数据类型，不会调用普通的函数模板
	//可以创建具体化的Person数据类型的模板，用于特殊处理这个类型;
	if (compare(p1, p2)) {
		cout << "p1与p2相等！" << endl;
	}else {
		cout << "p1与p2不相等！" << endl;
	}

	system("pause");
	return 0;
}

代码过程中的注意事项：
注意：因为模板一般为T类型，不够具体，而如果是用形参为T a 则需要复制一份一样的数据；
所以要解决这种不够具体的情况，一般是使用引用类型；T& a；直接使用原数据；

总结

• 利用具体化的模板，可以解决自定义类型的通用化；
• 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板；

类模板

类模板语法：

• 类模板作用：建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表；
  
  解释：
  template ——声明创建模板；
  typename ——表明其后面的符号是一种数据类型，可以用class代替；
  T —— 通用的数据类型，名称可以替换，通常为大写字母；

//类模板
template<typename nameType,typename ageType>
class Person {
public:
	Person(nameType name, ageType age) {
		this->m_name = name;
		this->m_age = age;
	}
	void showPerson() {
		cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
	}
	nameType m_name;
	ageType m_age;
};

int main() {
	Person<string, int> p("张三",99);
	p.showPerson();

	system("pause");
	return 0;
}

总结：类模板和函数模板语法类似，在声明模板template后面加类，此类称为类模板；

类模板与函数模板的区别：

• 类模板没有自动类型推导的使用方法
  
• 类模板在模板参数列表中可以有默认参数；
  
  （图示中的int;）
  

类模板中成员函数创建时机：

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

class Person1 {
public:
	void showPerson1() {
		cout << "Person1 show!" << endl;
	}
};
class Person2 {
public:
	void showPerson2() {
		cout << "Person2 show!" << endl;
	}
};
template<typename personClass>
class MyClass {
public:
	personClass p;
	//类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成；
	void printPerson1() {
		p.showPerson1();
	}
	void printPerson2() {
		p.showPerson2();
	}
};

int main() {
	MyClass<Person1> me;
	me.printPerson1();
	//编译会出错，说明函数调用才会创建成员函数；
	//me.printPerson2();

	system("pause");
	return 0;
}

总结：类模板中的成员函数并不是一开始就创建的，而是在调用的时候才去创建；

类模板对象做函数参数

• 学习目标：类模板实例化出的对象，向函数传参的方式；
  一共有三种传入方式：
• 1.指定传入的类型 ---- 直接显示对象的数据类型；

template<typename nameType,typename ageType>
class Person {
public:
	Person(nameType name, ageType age) {
		this->m_name = name;
		this->m_age = age;
	}
	void print() {
		cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
	}
	nameType m_name;
	ageType m_age;
};
//指定传入的类型--直接显示对象的数据类型
void showPerson(Person<string, int>& p) {
	p.print();
}
int main() {
	Person<string, int>p("张三", 99);
	showPerson(p);

	system("pause");
	return 0;
}

• 2.参数模板化——将对象中的参数变为模板进行传递；——实际上是利用了模板的自动类型推导；

//参数模板化——相当于类模板与函数模板的结合；
template<class T1,class T2>
void showPerson(Person<T1, T2>& p) {
	p.print();
	cout << "T1的类型为：" << typeid(T1).name() << endl;
	cout << "T2的类型为：" << typeid(T2).name() << endl;
}
int main() {
	Person<string, int>p("张三", 99);
	showPerson(p);

	system("pause");
	return 0;
}

• 3.整个类模板化——将这个对象类型模板化进行传递；——也是利用了模板的自动类型推导功能；

//整个类模板化——相当于类模板与函数模板的结合；
template<class T>
void showPerson(T& p) {
	p.print();
	cout << "T1的类型为：" << typeid(T).name() << endl;
}
int main() {
	Person<string, int>p("张三", 99);
	showPerson(p);

	system("pause");
	return 0;
}

总结：

• 通过类模板创建的对象，可以有三种方式向函数中进行传参；
• 使用比较广泛的是第一种：指定传入的类型；

类模板与继承：

当类模板碰到继承时，需要注意一下几点：

• 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型；
• 如果不指定，编译器无法给子类分配内存；
• 如果想灵活指定父类中T的类型，子类也需要变为类模板；
  

template<typename T>
class Base {
public:
	T obj1;
};
template<typename T>
class Son1 :public Base<T> {
public:
	Son1(T a) {
		this->age = a;
		cout << "子类的年龄为：" <<this->age <<endl;
	}
	T age;
};
//如果想灵活指定父类中T类型，子类也需要变为类模板
template<typename T1,typename T2>
class Son2 :public Base<T1> {
public:
	Son2(T1 a,T2 b) {
		this->age = a;
		this->name = b;
		cout << "子类2的年龄为：" << this->age << endl;
	}
	T1 age;
	T2 name;
};
int main() {
	Son1<int> s1(18);
	Son2<int, string> s2(20, "李四");
	system("pause");
	return 0;
}

总结：如果父类是类模板，子类需要指定出父类中T的数据类型；

以上两大板块都利用了模板的自动推导功能

类模板成员函数类外实现：

template<typename T1,typename T2>
class Person {
public:
	Person(T1 a,T2 b);
	T1 age;
	T2 name;
	void showPerson();
};
//构造函数类外实现
template<typename T1, typename T2>
Person<T1,T2>::Person(T1 a, T2 b) {
	this->age = a;
	this->name = b;
}
//成员函数类外实现
template<typename T1, typename T2>
void Person<T1,T2>::showPerson() {
	cout << "姓名为：" << this->name << " 年龄为：" << this->age<<endl;
}
int main() {
	Person<int, string> p(18, "李四");
	p.showPerson();

	system("pause");
	return 0;
}

::双冒号为作用域符；
如 ::即为全局作用域下：

类模板文件编写

• 掌握类模板成员函数分文件编写产生的问题以及解决方式；
  
  
• 方法一：直接包含.cpp源文件：
  

由于一般在main.cpp中只会包含.h头文件，所以方法一不常用；

• 将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制；
  
  （将模板类的声明和实现写在一起，并命名为.hpp文件，再在main主文件中包含即可；）

类模板与友元：

掌握类模板配合友元函数的类内和类外实现

• 全局函数类内实现——直接在类内声明友元即可；

template<typename T1, typename T2>
class Person {
	friend void showPerson(Person<T1,T2> p) {
		cout << "姓名为：" << p.name << " 年龄为：" << p.age << endl;
	}
public:
	Person(T1 a, T2 b) {
		this->age = a;
		this->name = b;
	}
	T1 age;
	T2 name;
};
int main() {
	Person<int, string> p(21,"小王");
	showPerson(p);

	system("pause");
	return 0;
}

• 全局函数类外实现——需要提前让编译器知道全局函数的存在；

//提前让编译器知道Person类存在
template<typename T1, typename T2>
class Person;
//类外实现
template<typename T1, typename T2>
void showPerson(Person<T1, T2> p) {
	cout << "类外实现——姓名为：" << p.name << " 年龄为：" << p.age << endl;
}

template<typename T1, typename T2>
class Person {
	//加空模板参数列表
	//如果全局函数是类外实现，需要让编译器提前知道这个函数的存在；
	friend void showPerson<>(Person<T1, T2> p);
public:
	Person(T1 a, T2 b) {
		this->age = a;
		this->name = b;
	}
	T1 age;
	T2 name;
};

int main() {
	Person<int, string> p(21,"小王");
	showPerson(p);

	system("pause");
	return 0;
}