C++类模板在不同情况下的使用

类模板和函数模板的定义和使用类似。
有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同。

1. 类模板用于实现类所需数据的类型参数化

类模板可以有默认参数，比如：

template<typename NameType, typename AgeType=int>

而函数模板不支持有默认参数
类模板不能进行类型自动推导：

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

void test01(){
	//Person P1("小明",18); // 类模板不能进行类型自动推导 
	Person<string, int>P1("小明", 18);
	P1.showPerson();
}

2. 类模板中成员函数 一开始不会创建出来，而是在运行时才去创建

class Person1{
public:
	void showPerson1(){
		cout << "Person1的调用" << endl;
	}
};
class Person2{
public:
	void showPerson2(){
		cout << "Person2的调用" << endl;
	}
};

template<typename T>
class myClass{
public:
	T obj;
	void func1(){
		obj.showPerson1();
	}
	void func2(){
		obj.showPerson2();
	}
};
//类模板中成员函数 一开始不会创建出来，而是在运行时才去创建
void test01(){
	myClass<Person1>m;
	m.func1();
	//m.func2();//连着上一条语句编译会不通过，因为已经确定好了T类型为Person1之后，执行obj.showPerson2();的时候会提示没有此函数
}

3. 类模板做函数参数

3.1 指定传输类型

//类模板
template<typename NameType, typename AgeType>
class Person{
public:
	Person(NameType name, AgeType age){
		this->mName = name;
		this->mAge = age;
	}
	void PrintPerson(){
		cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

//类模板做函数参数
void DoBussiness(Person<string,int>& p){//指定传输类型
	p.mAge += 20;
	p.mName += "_vip";
	p.PrintPerson();
}

int main(){
	Person<string, int> p("John", 30);
	DoBussiness(p);
	return EXIT_SUCCESS;
}

3.2 参数模板化

函数模板内套类模板，用函数模板的可以自动推导类型的特点
查看类型名称： typeid(T).name()

//类模板
template<typename NameType, typename AgeType>
class Person{
public:
	Person(NameType name, AgeType age){
		this->mName = name;
		this->mAge = age;
	}
	void PrintPerson(){
		cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

template<typename T1 ,typename T2>
void doWork2(Person<T1, T2> & p){//函数模板内套类模板，用函数模板的可以自动推导类型的特点
	//如何查看类型
	cout << typeid(T1).name() << endl;
	cout << typeid(T2).name() << endl;
	p.showPerson();
}
void test02(){
	Person <string, int> p("小明", 18);
	doWork2(p);
}

3.3 整体模板化

把整体类型模板化，让函数模板自动推导

template<typename T>
void doWork3(T&p){//把整体类型模板化，自动推导
	cout << typeid(T).name() << endl;
	p.showPerson();
}

void test03(){
	Person <string, int> p("小王", 18);

	doWork3(p);
}

4. 类模板派生普通类

子类实例化的时候需要具体化父类的类型，子类需要知道父类的具体类型是什么样的，这样c++编译器才能知道给子类分配多少内存

//父类类模板
template<typename T>
class Base{
	T m;
};
class Child1 : public Base<double> { //继承类模板的时候，必须要确定基类的大小
};

void test02(){
	Child1 d1;
}

5. 类模板派生类模板

继承类模板的时候，必须要确定基类的大小

//父类类模板
template<typename T>
class Base{
	T m;
};
template<typename T1 ，typename T2>
class Child2 : public Base<T2> { //继承类模板的时候，必须要确定基类的大小
public:
	T1 mParam;
};

void test02(){
	Child2<int,double> d2;//int mParam; double m;
}

6. 类模板类内实现

类内实现就是上面写的普通的类模板

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

void test01(){
	//Person P1("小明",18); // 类模板不能进行类型自动推导 
	Person<string, int>P1("小明", 18);
	P1.showPerson();
}

7. 类模板类外实现

类模板的类外实现是为了方便分文件，但是一般我们写了类模板之后不要进行分文件编写，写到同一个文件中，进行声明和实现，后缀名改为.hpp

#include<iostream>
#include<string>
using namespace std;

template<typename T1, typename T2>
class Person{
public:
	Person(T1 name, T2 age);
	void showPerson();

public:
	T1 mName;
	T2 mAge;
};

//类外实现
template<typename T1, typename T2>
Person<T1, T2>::Person(T1 name, T2 age){
	this->mName = name;
	this->mAge = age;
}

template<typename T1, typename T2>
void Person<T1, T2>::showPerson(){
	cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
}

void test(){
	Person<string, int> p("小明", 18);
	p.showPerson();
}

int main(){
	test();
	return EXIT_SUCCESS;
}

8. 模板类碰到友元函数

#include<iostream>
using namespace std;
#include <string>

//告诉编译器这个函数模板是存在的同时也要告诉编译器这个函数模板中用的类也是存在的
template<typename T1, typename T2> 
class Person;
//告诉编译器这个函数模板是存在
template<typename T1, typename T2> 
void PrintPerson2(Person<T1, T2>& p);

//友元函数在类内实现
template<typename T1, typename T2>
class Person{
	//1. 友元函数在类内实现
	friend void PrintPerson(Person<T1, T2>& p){
		cout << "Name:" << p.mName << " Age:" << p.mAge << endl;
	}

	//2.友元函数类外实现
	//告诉编译器这个函数模板是存在
	friend void PrintPerson2<>(Person<T1, T2>& p);//<>表示这是个模板

	//3. 类模板碰到友元函数模板
	template<typename U1, typename U2>
	friend void PrintPerson(Person<U1, U2>& p);

public:
	Person(T1 name, T2 age){
		this->mName = name;
		this->mAge = age;
	}
	void showPerson(){
		cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
	}
private:
	T1 mName;
	T2 mAge;
};

void test01(){
	Person <string, int>p("Jerry", 20);
	PrintPerson(p);
}

// 类模板碰到友元函数
//友元函数类外实现  加上<>空参数列表，告诉编译去匹配函数模板
template<typename T1, typename T2>
void PrintPerson2(Person<T1, T2>& p){
	cout << "Name2:" << p.mName << " Age2:" << p.mAge << endl;
}

void  test02(){
	Person <string, int>p("Jerry", 20);
	PrintPerson2(p);   //不写可以编译通过，写了之后，会找PrintPerson2的普通函数调用，因为写了普通函数PrintPerson2的声明	
}

int main(){
	//test01();
	test02();
	return EXIT_SUCCESS;
}