c++类模板

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

template<class NameType,class AgeType>
class Person1
{
public:
	Person1(NameType name, AgeType age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}
	void showPerson()
	{
		cout << "name : " <<this->m_Name << endl;
		cout << "age : " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};

类模板的格式和函数模板类似，可看上一篇文章再结合上面这段代码即可

类模板和函数模板的区别

1、类模板没有自动类型推导的使用方法，所以只能使用显示指定类型
2、类模板在模板参数类表中可以有默认参数，如：

template<class NameType, class AgeType = int>

这里的Agetype默认类型是int类型

类模板对象做函数参数

类模板实例化出的对象，向函数传参有三种传入方式

1、指定传入类型：  直接显示对象的数据类型
2、参数模板化：    将指定的参数变为模板进行传递
3、整个类模板化：  将这个对象类型模板化进行传递

template<class NameType,class AgeType = int>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "name:" << this->m_Name << endl;
		cout << "age:" << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};

1、指定传入类型 类模板的对象做函数参数

void printPerson(Person<string, int>&p)
{
	p.showPerson();
}
void test01()
{
	Person<string, int>p1("***", 20);
	printPerson1(p1);
}

2、参数模板化： 函数模板配合类模板

template<class NameType, class AgeType = int>
void printPerson(Person<NameType, AgeType>& p)
{
	p.showPerson();
	cout << "NameType 的类型" << typeid(NameType).name() << endl;
	cout << "AgeType 的类型" << typeid(AgeType).name() << endl;
}
void test02()
{
	Person<string, int>p1("***", 22);
	printPerson(p1);
}

这里需要额外记一下在c++中查看变量类型的方法
typeid(变量名).name();
3、整个类模板化： 函数模板配合类模板

template<class T>
void printPerson(T &p)
{
	p.showPerson();
	cout << "T  的数据类型为：" << typeid(T).name() << endl;
}
void test03()
{
	Person<string, int>p1("***", 21);
	printPerson(p1);
}

主要用的是第一种，另外两种了解就好

类模板与继承

//当类模板碰到继承时，需要注意

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

1、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型

template<class T>
class Base
{
	T m;
};
//class son :public Base  错误
class Son :public Base<int>//必须要指定类型，否则会报错，必须要知道父类中的T类型，才能继承给子类
{
	//这时 T就只能是int类型
};

//2、如果想灵活指出父类中的T类型，子类也需要变为模板类

template<class T1,class T2>
class Son :public Base<T2>//T1是子类的，T2是父类的
{
public:
	Son()
	{
		cout<<"T1的类型为：" << typeid(T1).name() << endl;
		cout<<"T2的类型为：" << typeid(T2).name() << endl;
	}
	T1 obj{};
};

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

template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	void showPerson();
	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>::showPerson()
{
	cout << "name:" << this->m_Name << endl;
	cout << "age:" << this->m_Age << endl;
}

类模板的分文件编写

首先我们要清楚的时类模板中的成员函数的创建时机是在调用时创建，这就导致我们在分文件编写时，如果只包含它的.h头文件时，编译器只看到了.h中的函数声明，并没有创建函数，所以根本就看不到.cpp文件中的代码
所以要解决这样的问题有两种方法：
第一种就是直接包含它的.cpp文件
第二种就是将类模板的声明和实现都写在一个文件中，并更改文件后缀名为.hpp,当然了这里的.hpp是约定的名字，并不是强制