C++语言中的模板——类模板

概述：
类模板和函数模板的定义和使用类似，我们已经进行了介绍。有时，有两个或多个 类，其功能是相同的，仅仅是数据类型不同。 类模板用于实现类所需数据的类型 参数化。
比如以下代码：

class Animal
{
public:
	int age;
	int data;
};

void test01()
{
	Animal Dog;
	Animal Cat;
}

我使用Animal类定义对象的时候，只能定义成员变量类型为int类型的，假如我现在需要一个string类型的变量，我们一般是再写一个类然后改变里面成员类型。
这是就需要一个模板来避免代码繁琐，提高代码的重用，可以这样来定义

template <class T1,class T2>

class Animal
{
public:
	Animal(T1 a,T2 b)
	{
		age = a;
		data = b;
	}
	T1 age;
	T2 data;
};
class Animal_1
{
public:
	int age;
	string name;
};
void test01()
{
	/*类型不同*/
	Animal<int,int> dog(10, 888);//类模板不能自动类型推导，说明变量类型
	Animal<int,string> Cat(1,"test");
}
int main()
{
	test01();
	return 0;
}

类模板和函数模板实现的功能一样，但是类模板使用的时候需要指明参数类型，比如Animal<int,int> dog(10, 888);因为类模板不能自动类型推到。
类模板作为函数参数：

class Animal
{
public:
	Animal(T1 a,T2 b)
	{
		age = a;
		data = b;
	}
	T1 age;
	T2 data;
};
/*第一种方法*/
template <class T1, class T2>
void show1(Animal<T1, T2>&p)
{
	cout << p.age << endl;
	cout << p.data << endl;
}
/*第二种方法*/
template <class T>
void show2(T& p)
{
	cout << p.age << endl;
	cout << p.data << endl;
}

void test01()
{
	/*类型不同*/
	Animal<int,int> dog(10, 888);//类模板不能自动类型推导，说明变量类型
	Animal<int,string> Cat(1,"test");
	show1(dog);
	show1(Cat);
	show1<int, string>(Cat);
	show2(dog);
	show2 <Animal<int, int>>(dog);//整个类型传过来
}
int main()
{
	test01();
	return 0;
}

/*类模板作为函数形参，可以将函数写为函数模板，可以自动推到*/

注意：第一种方法传类型的时候传的是<int,string>而第二种方法是整个类型 <Animal<int, int>>
类模板遇到继承
1，类模板遇到继承，在继承的时候，继承的类必须是一个模板类并且指定类型
2，类模板遇到继承，可以将子类写成类模板
如以下代码：

#include <iostream>
#include <string>

using namespace std;
template <class T>

class Base
{
public:
	Base(T A)
	{
		a = A;
	}
	T a;
};
/*一定要告诉编译所继承的基类模板类型*/

class A :public Base<int>
{
public:
	A(int x1, int x2) :Base<int>(x1),x(x2) {}
	
	int x;
};

template <class T1,class T2>
class B :public Base<T2>
{
public:
	B(T1 x1, T2 x2) :Base<T2>(x2), x(x1) {}
	T1 x;
};
void test01()
{
	A a(1, 3);
	B<int, string> b(10, "test");

}
int main()
{
	test01();
	return 0;
}

类模板成员函数类内实现
类模板函数在类内实现和普通函数实现相似，直接访问即可

template <class T1,class T2>
class Person
{
public:
	Person(T1 a,T2 b)
	{
		this->a = a;
		this->b = b;
	}
	void show()
	{
		cout << a << endl;
		cout << b << endl;
	}

	T1 a;
	T2 b;


};

void test01()
{
	Person<int,string> p1(100, "test");
	p1.show();
}

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

template <class T1,class T2>
class Person
{
public:
	Person(T1 a, T2 b);
	void show();
	T1 a;
	T2 b;
};
//类模板成员函数在类外实现需要写成函数模板
template <class T1, class T2>
Person<T1,T2>::Person(T1 a, T2 b)
{
	this->a = a;
	this->b = b;
}
template <class T1, class T2>
void Person<T1, T2>::show()
{
	cout << a << endl;
	cout << b << endl;
}
void test01()
{
	Person<int,string> p1(100, "test");
	p1.show();
}

成员函数在类外实现的时候需要写成函数模板，并且在每个函数前面要加上作用域，但是和普通函数不一样还需要加上类模板的类型Person<T1, T2>。
类模板遇到友元函数

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

template<class T1, class T2> class Person;
//告诉编译器这个函数模板是存在
template<class T1, class T2> void PrintPerson2(Person<T1, T2>& p);

//友元函数在类内实现
template<class T1, class 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<class U1, class 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<class T1, class 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(); system("pause"); 

	return 0;
}