类模板
1、类模板语法
类模板作用：
建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟类型来代替。
#include <iostream>
#include <string>
using namespace std;
//类模板
template<class NameType, class AgeType>
class Person
{
public:
Person(NameType name, AgeType age)
{
this->m_Name = name;
this->m_age = age;
}
void showPerson()
{
cout << "name = " << this->m_Name << " age = " << this->m_age << endl;
}
NameType m_Name;
AgeType m_age;
};
void test1()
{
Person <string, int>p1("Tom", 10);
p1.showPerson();
}
int main()
{
test1();
system("pause");
return 0;
}
注意：在Person类中，有两种不同类型的数据，此时不能仅仅只用一种类型T，休要定义出不同的类型，如：
template<class NameType, class AgeType>
2、类模板与函数模板区别
1、类模板没有自动类型推导的使用方式；
2、类模板在模板参数列表中可以有默认参数。
template<class NameType, class AgeType = int>
Person<string>p("Jarry", 10);
#include <iostream>
#include <string>
using namespace std;
//类模板与函数模板的区别
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 = " << m_Name << " age = " << m_Age << endl;
}
NameType m_Name;
AgeType m_Age;
};
//1、类模板没有自动类型推导的使用方式；
void test1()
{
//Person p("Tom", 10);错误
Person<string, int>p("Tom", 10);
p.showPerson();
}
//2、类模板在模板参数列表中可以有默认参数。
void test2()
{
Person<string>p("Jarry", 10);
p.showPerson();
}
int main()
{
test1();
test2();
system("pause");
return 0;
}
3、类模板在成员函数中的创建时机
1、普通函数中的成员函数一开始就可以创建；
2、类模板的成员函数在调用时才创建；
4、类模板对象做函数参数
一共三种传入方式：
1、指定传入的类型——直接显示对象的数据类型；
2、参数模板化 ——将对象中的参数变为模板进行传递；
3、整个类模板化 ——将这个对象类型模板进行传递；
#include <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.showPerson();
}
void test1()
{
Person<string, int> p("Tom", 10);
printPerson1(p);
}
//2、参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2> p)
{
p.showPerson();
cout << "T1的类型为：" << typeid(T1).name() << endl;
cout << "T2的类型为：" << typeid(T2).name() << endl;
}
void test2()
{
Person<string, int> p("Jarray", 9);
printPerson2(p);
}
//3、整个类模板化
template<class T>
void printPerson3(T &p)
{
p.showPerson();
cout << "T的类型为：" << typeid(T).name() << endl;
}
void test3()
{
Person<string, int> p("John", 11);
printPerson3(p);
}
int main()
{
test1();
test2();
test3();
system("pause");
return 0;
}
在三种方法中，最常用的是指定传入的类型。5、类模板与继承
当类模板碰到继承时：
1、当子类继承的父类是一个类模板时，子类在声明的时候，要指出父类中的T的类型，如果不指定，编译器无法给子类分配内存；
2、如果想灵活制定出父类中T的类型，子类也需要变为类模板。
#include <iostream>
using namespace std;
template<class T>
class Base
{
T m;
};
//class Son :public Base //错误，必须要知道父类中T的数据类型。
class Son :public Base<int>
{};
void test1()
{
Son s1;
}
//如果想灵活制定出父类中T的类型，子类也需要变为类模板。
template<class T1, class T2>
class Son2 :public Base<T2>
{
public:
Son2()
{
cout << "T1的类型为：" << typeid(T1).name() << endl;
cout << "T2的类型为：" << typeid(T2).name() << endl;
}
T1 obj;
};
void test2()
{
Son2<int, char> s2;
}
int main()
{
test2();
system("pause");
return 0;
}
6、类模板成员函数的类外实现
#include <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;
};
//构造函数类外实现
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 test1()
{
Person<string, int> P("Tom", 10);
P.showPerson();
}
int main()
{
test1();
system("pause");
return 0;
}
实现的主要代码：
template<class T1, class T2> Person<T1, T2>::Person(T1 name, T2 age)
template<class T1, class T2> void Person<T1, T2>::showPerson()
7、类模板分文件编写
问题：类模板中成员函数创建时机在调试阶段，导致分文件编写时链接不到。
解决：
1、直接包含.cpp文件；
2、将声明和实现写到同一个文件中，并更改后缀名.hpp，.hpp是约定的名称，并不是强制。
8、类模板与友元
全局函数类内实现：直接在类内声明友元即可；
全局函数类外实现：需要提前让编译器知道全局函数的存在。
#include <iostream>
#include <string>
using namespace std;
//通过全集函数打印Person的信息
//提前让编译器知道Person类的存在
template<class T1, class T2>
class Person; //模板类
//类外实现
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
{
//全局函数 类内实现
friend void printPerson1(Person<T1, T2> P)
{
cout << "类内实现——姓名：" << P.m_Name << " 年龄：" << P.m_Age << endl;
}
//全局函数类外实现
//加空模板参数列表
//需要提前让编译器知道全局函数的存在。
friend void printPerson2<>(Person<T1, T2> P);
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
//1、全局函数类内实现
void test1()
{
Person<string, int> P("Tom", 10);
printPerson1(P);
}
//2、全局函数类外实现
void test2()
{
Person<string, int> P("Jerry", 10);
printPerson2(P);
}
int main()
{
test1();
test2();
system("pause");
return 0;
}
