目录

简介

类模板和成员函数创建时机

类模板对象做函数参数

类模板与继承

类模板成员函数类外实现

类模板分文件编写

类模板与友元

---

简介

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

语法

template<typename T>
类

案例

#include 
using namespace std; 
template<class NameType,class AgeType=int>
class Person {
public:
	Person(NameType name, AgeType age) {
		this->mName = name;
		this->mAge = age;
	}
	void showPerson() {
		cout << "name: " << this->mName << "age: " << this->mAge << endl;
	}
private:
	NameType mName;
	AgeType mAge;
};
int main() 
{  
	Person<string,int> p("lll", 10);//这里必须声明类型
	p.showPerson();
	return 0; 
}

类模板与函数模板的区别

1.类模板没有自动类型推到的使用方式

2.类模板在模板参数列表中可以有默认参数

类模板和成员函数创建时机

普通类中的成员函数是一开始就可以创建的

类模板中的成员函数在调用时才可以创建

案例

#include 
using namespace std; 
class p1 {
public:
	void showp1() {
		cout << "show p1" << endl;
	}
};
class p2 {
public:
	void showp2() {
		cout << "show p2" << endl;
	}
};
template<class T>
class Person {
public:
	T obj;
	void fun1() {
		obj.showp1();
	}
	void fun2() {
		obj.showp2();
	}
};
int main() 
{  
	Person p;
	p.fun1();
	//p.fun2(); 编译出错说明是函数调用才会创建成员函数
	return 0; 
}

类模板对象做函数参数

一共有三种传入方式

1.指定传入的类型--直接显示对象的数据类型(最常用)

2.参数模板化--将对象中的参数变为模板进行传递

3.整个类模板化--将这个对象类型模板化进行传递

案例:

#include 
using namespace std;
template<class NameType, class AgeType = int>
class Person {
public:
	Person(NameType name, AgeType age) {
		this->mName = name;
		this->mAge = age;
	}
	void showPerson() {
		cout << "name: " << this->mName << "age: " << this->mAge << endl;
	}
private:
	NameType mName;
	AgeType mAge;
};
//1.指定传入的类型
void printPerson1(Personint>& p) {
	p.showPerson();
}
//2.参数模板化
template<class T1, class T2>
void printPerson2(Person& p) {
	p.showPerson();
}
//3.整个类模板化
template<class T>
void printPerson3(T & p){
	p.showPerson();
}
int main() 
{  
	Personint> p("a", 10);
	printPerson1(p);
	printPerson2(p);
	printPerson3(p);
	return 0; 
}

类模板与继承

注意事项

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

2.如果不指定，编译器无法给子类分配内存

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

案例

#include 
using namespace std;
template<class T>
class Base {
	T m;
};
class son :public Base<int>
{
 
};
template<class T>
class son2 :public Base {
	
};
int main() 
{  
	son s;
	son2<int> s2;
	return 0; 
}

类模板成员函数类外实现

类模板中成员函数类外实现的时候需要加入模板参数列表

#include 
using namespace std;
template<class T1, class T2>
class Person {
public:
	//成员函数类内声明
	Person(T1 name, T2 age);
	void showPerson();
public:
	T1 m_Name;
	T2 m_Age;
};
template<class T1,class T2>
Person::Person(T1 name, T2 age) {
	this->m_Name = name;
	this->m_Age = age;
}
template<class T1,class T2>
void Person::showPerson() {
	cout << "姓名:" << this->m_Name << "年龄:" << this->m_Age << endl;
}
int main() 
{  
	Personint> p("hehe", 10);
	p.showPerson();
	return 0; 
}

类模板分文件编写

将声明和实现写到同一个文件中，并更名为.hpp，.hpp是约定俗成的名字，不是强制

.hpp头文件

#pragma once
#include 
using namespace std;
template<class T1, class T2>
class Person {
public:
	//成员函数类内声明
	Person(T1 name, T2 age);
	void showPerson();
public:
	T1 m_Name;
	T2 m_Age;
};
template<class T1, class T2>
Person::Person(T1 name, T2 age) {
	this->m_Name = name;
	this->m_Age = age;
}
template<class T1, class T2>
void Person::showPerson() {
	cout << "姓名:" << this->m_Name << "年龄:" << this->m_Age << endl;
}

.cpp文件

#include 
using namespace std;
#include"person.hpp"
int main() 
{  
	Personint> p("hehe", 10);
	p.showPerson();
	return 0; 
}

类模板与友元

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

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

案例

#include 
using namespace std;
template<class T1, class T2> class Person;
 //如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
template<class T1, class T2> void show2(Person & p);
 
//这里由于show2在类之前实现所以前面要先声明Person 如过在Person类之后实现则不用
template<class T1,class T2>
class Person {
public:
	Person(T1 name, T2 age) {
		this->m_name = name;
		this->m_age = age;
	}
	//1.全局函数友元类内实现
	friend void show1(Person& p) {
		cout << p.m_name << " " << p.m_age << endl;
	}
	//2.全局函数友元类外实现
	friend void show2<>(Person& p);
private:
	T1 m_name;
	T2 m_age;
};
template<class T1, class T2>
void show2(Person& p) {
	cout << p.m_name << " " << p.m_age << endl;
}
int main() 
{  
	Personint> p("aa", 10);
	show1(p);
	show2(p);
	return 0; 
}