学习：类模板

类模板的使用：

类模板作用：

建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。

在自己看来是给自己创建的类来使用的模板

语法：

template<typename T>
类

解释：

template --- 声明创建模板

typename --- 表面其后面的符号是一种数据类型，可以用class代替

T --- 通用的数据类型，名称可以替换，通常为大写字母

示例代码

#include<iostream>
#include<string>
using namespace std;
 
template<class NameType, class AgeType>  //定义一个类模板
class Person {
public:
	Person(NameType name, AgeType age) {
		this->age = age;
		this->name = name;
	}
 
	void showinfo() {
		cout << this->age << endl;
		cout << this->name << endl;
	}
public:
	NameType name;
	AgeType age;
};
 
void test01() {
	Person<string, int>p1("adexx", 18);
	p1.showinfo();
 
}
 
 
int main() {
	test01();
	system("pause");
	return 0;
 
}

---

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

1、类模板不会自动推导的使用方式，也就是调用的时候需要自己指定类型
2、类模板在模板参数列表中可以有默认参数，下面的代码中会有体现

示例代码：

#include<iostream>
#include<string>
 
using namespace std;
 
template<class NameType, class AgeType = int>  //定义一个类模板,我们还可以对传参进行指定默认参数
class Person {
public:
	Person(NameType name, AgeType age) {  
		this->age = age;
		this->name = name;
	}
 
	void showinfo() {
		cout << this->age << endl;
		cout << this->name << endl;
	}
public:
	NameType name;
	AgeType age;
};
 
int main() {
	//Person p1("adexx", 18); //直接生成不行，需要指定类型
	//Person<string, int>p1("adexx", 18); //可以
	Person<string>p1("adecc", 19);//对上面指定了默认参数 只需要指定一个类型string就可以
	system("pause");
	return 0;
}

总结：

1、类模板使用只能用显示指定类型方式
2、类模板中的模板参数列表可以有默认参数

---

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

类模板中成员函数和普通类中成员函数创建时机是有区别的：

1、普通类中的成员函数一开始就可以创建
2、类模板中的成员函数在调用时才创建

示例代码：

#include<iostream>
#include<string>
using namespace std;
 
class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1 show" << endl;
	}
};
 
class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2 show" << endl;
	}
};
 
template<class T>
class Myclass {
public:
 
	T obj;
	void func1() {
		obj.showPerson1();
	}
 
	void func2() {
		obj.showPerson2();
	}
};
 
 
int main() {
	Myclass<Person1> m;
	m.func1();
	//m.func2();  两条一起执行就会报错， 但是注释掉一条就不会报错，所以说明了类模板中的函数调用的时候只有调用的时候才创建，要不然不创建
	system("pause");
	return 0;
 
}

---

类模板与继承：

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

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

示例代码：

#include<iostream>
#include<string>
using namespace std;
 
template<class T>
class A {
public:
 
	T age;
};
 
//class B :public A {  无法直接继承父类模板 需要指定参数才行
//
//};
 
 
class C:public A<int> { //第一点的体现，这样的是可以生成的 ，但是也有个缺点，这样子的话父类只能是我们设定的类型，在这里的话 就只能是int类型了，那有什么办法能更灵活点呢
 
};
 
 
template<class T1,class T2>
class B :public A<T2>{ // 第三点的体现
public:
	B(T1 name) {
		this->name = name;
		cout << this->name << endl;
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
public:
	T1 name;
};
 
 
int main() {
	B<string, int>b1("adexx"); // B指定的参数 string为类模板的T1，int为子类中的T2也就是父类的T-age
	system("pause");
	return 0;
 
}

---

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

示例代码：

#include<iostream>
#include<string>
using namespace std;
 
 
//类模板成员函数的类外实现
 
 
//定义一个类模板Person
template<class AgeT,class NameT>
class Person {
public:
	//进行函数申明
	Person(AgeT age,NameT name);
	void showinfo();
 
public:
	AgeT m_age;
	NameT m_name;
};
 
//类外成员函数实现
 
template<class AgeT,class NameT>
Person<AgeT,NameT>::Person(AgeT age,NameT name) { //类外进行定义构造函数
	this->m_age = age;
	this->m_name = name;
}
 
template<class AgeT,class NameT>
void Person<AgeT, NameT>::showinfo() { // 类外进行定义成员函数
	cout << this->m_age << " " << this->m_name << endl;
}
 
int main() {
	Person<int,string>p1(18, "adexx");
	p1.showinfo();
	system("pause");
	return 0;
 
}

总结：类模板中成员函数类外实现时，需要加上模板参数列表，例如上面的就是加上<AgeT, NameT>

---

类模板的分文件编写：

问题：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

解决方式1：直接包含.cpp源文件
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

学到这里其实自己也还是不太懂为什么要这样搞，主要链接的原理不太懂，学到后面自己再慢慢进行理解嗯吧

示例代码：
person.hpp

#pragma once
#include<iostream>
#include<string>
 
using namespace std;
 
template<class t1, class t2>
class Person {
 
public:
	Person(t1 name, t2 age);
	void showInfo();
 
public:
	t1 m_name;
	t2 m_age;
};
 
template<class t1, class t2>
Person< t1, t2>::Person(t1 name, t2 age) {
	this->m_name = name;
	this->m_age = age;
}
 
 
template<class t1, class t2>
void Person< t1, t2>::showInfo() {
	cout << this->m_age << endl;
	cout << this->m_name << endl;
}

源.cpp

#include "person.hpp"
 
//template<class t1,class t2>
//class Person {
//
//public:
//	Person(t1 name,t2 age);
//	void showInfo();
//
//public:
//	t1 m_name;
//	t2 m_age;
//};
//
//template<class t1,class t2>
//Person< t1, t2>::Person(t1 name, t2 age) {
//	this->m_name = name;
//	this->m_age = age;
//}
//
//
//template<class t1,class t2>
//void Person< t1,  t2>::showInfo() {
//	cout << this->m_age << endl;
//	cout << this->m_name << endl;
//}
 
 
 
 
int main() {
	Person<string, int> p1("zpchcbd", 18);
	p1.showInfo();
	system("pause");
	return 0;
 
}

---

类模板与友元：

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

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

示例代码：

#include<iostream>
#include<string>
using namespace std;
 
template<class t1, class t2>class Person; //全局函数配合友元  类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
 
template<class t1, class t2>
void showInfo2(Person<t1, t2> & p1)  //因为类中已经进行friend声明，所以而可以直接进行定义了
{
	cout << "类外实现---- 姓名： " << p1.m_name << " 年龄：" << p1.m_age << endl;
}
 
template<class t1,class t2>
class Person {
public:
 
	Person(t1 m_age,t2 m_name) { //构造函数
		this->m_age = m_age;
		this->m_name = m_name;
	
	}
 
	friend void showInfo2<>(Person<t1, t2> & p1); //全局函数类外实现
 
	friend void showInfo(Person<t1,t2> & p1) {  //全局函数类内实现，这里头一次学习到friend来声明类内函数，类外可以直接进行调用 参考文章https://www.jianshu.com/p/2dffb88b0fe5
		cout << p1.m_age << endl;
		cout << p1.m_name << endl;
	}
private:
	t1 m_age;
	t2 m_name;
};
 
void test01() { //全局函数类内实现
	Person<int, string>p1(18, "adexx");
	showInfo(p1);
}
 
void test02() { //全局函数类外实现
	Person<int, string>p1(18, "adexx");
	showInfo2(p1);
}
 
int main() {
	//test01(); 全局函数类内实现调用
	test02(); //全局函数类外实现调用
	system("pause");
	return 0;
}