C++编程入门之三（类模板）

类模板：建立一个通用类，类中的成员、数据类型可以不具体制定，用一个虚拟的类型来代表。
一 . 语法：
template
class 变量名（）
{
类内容
}
二. 类模板中成员函数和普通类中成员函数创建时机是有区别的：
普通类中的成员函数一开始就可以创建。
类模板中的成员函数在调用时才创建。
三. 类模板对象做函数参数：
类模板实例化出的对象，向函数传参的方式，有三种传入方式

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

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

template<class T1,class T2>
class Person
{
public:
Person(T1 name,T2 age)
{
this->m_Name = name;
this->m_Age = age;
}

void showPerson()
{
cout<<"姓名："<<this->m_Name<<"年龄："<<this->m_Age<<endl;
}
T1 m_Name;
T2 m_Age;
}

//1.指定传入类型，常用
void printPerson1(Person<string,int>&p)
{
p.showPerson1();
}
void test01()
{
Person<string,int>p("孙悟空",100);
}
//2.参数模板化
template<class T1,class T2>
void printPerson2(Person<T1,T2>&p)  //j将string和int变为T1和T2，并在上面对T1和T2进行说明
{
p.showPerson();
cout<<"T1的类型为"<<typeid(T1).name()<<endl;  //查看T1的类型
cout<<"T2的类型为"<<typeid(T2).name()<<endl;  //查看T2的类型
}
void test02()
{
Person<string,int>p("猪八戒",90);
printPerson2(p);

}
//3.整个类模板化
template<class T>
void printPerson3(T &p)  //将整个Person<string,int>p转换为T，并在上面对T进行说明
{
p.showPerson();
cout<<"T的类型为"<<typeid(T).name()<<endl;  //查看T的类型
}
void test03()
{
Person<string,int>p("唐僧",30);
printPerson3(p);
}

int main()
{
test01();
test02();
test03();

system("pause");
return 0;
}

四.类模板和继承

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

1.当子类继承的父类是一个类模板时，子类在声明的时候，要制定出父类中T的类型，如果不指定，编译器无法给子类分配内存。

2.如果想灵活指定出父类中T的类型，子类也需变为类模板。

#include"pch.h"
#include<iostream>
#include<string>
#include<opencv2/opencv.hpp>


using namespace std;
using namespace cv;

//类模板与继承
template<class T>
class Base
{
	T m;
};

//class Son : public Base //错误，必须要知道父类中T的类型才能继承给子类
class Son : public Base<int>
{

};

void test01()
{
	Son s1;
}
//如果想灵活指定父类中T类型，子类也需要变类模板
template<class T1,class T2>
class Son2 :public Base<T2>
{
public:   //建立一个构造函数查看T1和T2的数据类型
	Son2()
	{
		cout << "T1的类型为： " << typeid(T1).name() << end;
		cout << "T1的类型为： " << typeid(T1).name() << end;
	}
	T1 obj;
};
void test02()
{
	Son2<int, char>S2;  
}

int main()
{
	test01();
	test02();

	system("pause");
	return 0;
};

T1得到int类型，返回obj；而char的类型给到T2后，返回到父类T，此时m的类型为插入类型。

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

五.类模板成员函数类外实现

类模板中成员还函数类外实现时，需要加上模板参数列表

#include"pch.h"
#include<iostream>
#include<string>
#include<opencv2/opencv.hpp>


using namespace std;
using namespace cv;

//类模板与继承
template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	/*{
		this->m_Name = name;
		this->m_Age = age;
	}*/
	void showPerson();
	/*{
		cout << "姓名： " << this->m_Name << "年龄：" << this->m_Age << end;
	}*/
	T1 m_Name;
	T2 m_Age;
};
//构造函数的类外实现
template<class T1,class T2>
Person<T1,T2>::Person(T1 name, T2 age)//添加作用域Person:: 添加<T1,T2>说明为类模板
{
	this->m_Name = name;
	this->m_Age = age;
}
//成员函数类外实现
template<class T1,class T2>
void Person<T1, T2>::showPerson() //添加作用域Person:: 添加<T1,T2>说明为类模板
{
	cout << "姓名： " << this->m_Name << " 年龄：" << this->m_Age << endl;
}
void test01()
{
	Person<string, int>P("Tom", 20);
	P.showPerson();
}
int main()
{
	test01();

	system("pause");
	return 0;
}

六.类模板分文件编写
类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到，有两种解决方式：
解决方式1：直接包含.cpp源文件。
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp,hpp是约定的名称，并不是强制。

#include"pch.h"
#include<iostream>
#include<string>
#include<opencv2/opencv.hpp>
//第一种解决方式，直接包含源文件
#include"Person.cpp"
//第二种解决方式，将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件
//（.hpp文件为类模板文件）
#include"Person.hpp" //将.cpp中的文件写入.h的文件中，并改为.hpp文件
using namespace std;
using namespace cv;

//类模板分文件编写问题及解决
//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 << "姓名： " << this->m_Name << "年龄： " << this->m_Age << endl;
//}
void test01()
{
	Person<string, int>p("Jerry", 18);
	p.showPerson();
}
int main()
{
	test01();

	system("pause");
	return 0;
}

.hpp中的代码

#pragma once
#include<iostream>

using namespace std;

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 << "姓名： " << this->m_Name << "年龄： " << this->m_Age << endl;
}

.cpp中的代码

#include"pch.h"
//#include"Person.h"
//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 << "姓名： " << this->m_Name << "年龄： " << this->m_Age << endl;
//}

七. 类模板与友元
全局函数类内实现—直接在类内声明友元即可
全局函数类外实现—需要提前让编译器知道全局函数的存在
建议全局函数做类内实现，用法简单，而且编译器可以直接识别。

//代码有问题，不能运行，但原理已说明
#include"pch.h"
#include<iostream>
#include<string>
#include<opencv2/opencv.hpp>

using namespace std;
using namespace cv;
//通过全局函数打印Person信息

//提前让编译器知道Person类存在
template<class T1, class T2>
class Person;
//2.全局函数在类外实现
//printPerson2的实现函数
//类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2>p)
{
	cout << "类外实现---姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;

}

template<class T1,class T2>
class Person
{
public:
	//全局函数 类内实现
	friend void printPerson(Person<T1, T2>p)
	{
		cout << "姓名：" <<  p.m_Name << " 年龄：" << p.m_Age << endl;
	}
	//全局函数 类外实现
	//加空模板参数列表
	//如果全局函数是类外实现，需要让编译器提前知道这个函数的存在，将实现函数剪切到开头
	friend void printPerson2(Person<T1, T2>p);
	Person(T1 name, T2 age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}
private:
	T1 m_Name;
	T2 m_Age;
};

//1、全局函数在类内实现
void test01()
{
	Person<string, int>p("Tom", 18);
	printPerson(p);
}
void test02()
{
	Person<string, int>p("Jerry", 20);
	printPerson2(p);
}


int main()
{
	test01();
	test02();

	system("pause");
	return 0;
}