夜雨聆风1.5 模板机制剖析
思考:为什么函数模板可以和普通函数放在一起?c++编译器是如何实现函数模板机制的？
1.5.1编译过程
hello.cpp程序是高级c语言程序，这种程序易于被人读懂。为了在系统上运行hello.c程序，每一条c语句都必须转化为低级的机器指令。然后将这些机器指令打包成可执行目标文件格式，并以二进制形式存储于磁盘中。
预处理(Pre-processing) -> 编译(Compiling) ->汇编(Assembling) -> 链接(Linking)
1.5.2 模板实现机制
函数模板机制结论：
l编译器并不是把函数模板处理成能够处理任何类型的函数
l函数模板通过具体类型产生不同的函数
l编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。
1.6模板的局限性
假设有如下模板函数：
template<class T>
void f(T a, T b)
{ … }
如果代码实现时定义了赋值操作 a = b，但是T为数组，这种假设就不成立了
同样，如果里面的语句为判断语句 if(a>b),但T如果是结构体，该假设也不成立，另外如果是传入的数组，数组名为地址，因此它比较的是地址，而这也不是我们所希望的操作。
总之，编写的模板函数很可能无法处理某些类型，另一方面，有时候通用化是有意义的，但C++语法不允许这样做。为了解决这种问题，可以提供模板的重载，为这些特定的类型提供具体化的模板。
classPerson
{
public:
Person(stringname, intage)
{
this->mName = name;
this->mAge = age;
}
stringmName;
intmAge;
};
//普通交换函数
template <classT>
voidmySwap(T &a,T &b)
{
Ttemp = a;
a = b;
b = temp;
}
//第三代具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//具体化优先于常规模板
template<>voidmySwap<Person>(Person &p1, Person &p2)
{
stringnameTemp;
intageTemp;
nameTemp = p1.mName;
p1.mName = p2.mName;
p2.mName = nameTemp;
ageTemp = p1.mAge;
p1.mAge = p2.mAge;
p2.mAge = ageTemp;
}
voidtest()
{
PersonP1("Tom", 10);
PersonP2("Jerry", 20);
cout << "P1 Name = " << P1.mName << " P1 Age = "<< P1.mAge << endl;
cout << "P2 Name = " << P2.mName << " P2 Age = "<< P2.mAge << endl;
mySwap(P1, P2);
cout << "P1 Name = " << P1.mName << " P1 Age = "<< P1.mAge << endl;
cout << "P2 Name = " << P2.mName << " P2 Age = "<< P2.mAge << endl;
}
1.7 类模板
1.7.1 类模板基本概念
类模板和函数模板的定义和使用类似，我们已经进行了介绍。有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同。
l类模板用于实现类所需数据的类型参数化
template<classNameType, classAgeType> classPerson { public: Person(NameTypename, AgeTypeage) { this->mName = name; this->mAge = age; } voidshowPerson() { cout << "name: " << this->mName << " age: " << this->mAge << endl; } public: NameTypemName; AgeTypemAge; }; voidtest01() { //Person P1("德玛西亚",18); // 类模板不能进行类型自动推导 Person<string, int>P1("德玛西亚", 18); P1.showPerson(); } |
1.7.2 类模板做函数参数
//类模板 template<class NameType,class 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); system("pause"); return EXIT_SUCCESS; } |
1.7.3 类模板派生普通类
//类模板 template<class T> class MyClass{ public: MyClass(T property){ this->mProperty = property; } public: T mProperty; }; //子类实例化的时候需要具体化的父类，子类需要知道父类的具体类型是什么样的 //这样c++编译器才能知道给子类分配多少内存 //普通派生类 class SubClass :public MyClass<int>{ public: SubClass(int b): MyClass<int>(20){ this->mB = b; } public: int mB; }; |
1.7.4 类模板派生类模板
//父类类模板 template<classT> classBase { Tm; }; template<classT > classChild2 : publicBase<double>//继承类模板的时候，必须要确定基类的大小 { public: TmParam; }; voidtest02() { Child2<int> d2; } |
1.7.5 类模板类内实现
template<classNameType, classAgeType> classPerson { public: Person(NameTypename, AgeTypeage) { this->mName = name; this->mAge = age; } voidshowPerson() { cout << "name: " << this->mName << " age: " << this->mAge << endl; } public: NameTypemName; AgeTypemAge; }; voidtest01() { //Person P1("德玛西亚",18); // 类模板不能进行类型自动推导 Person<string, int>P1("德玛西亚", 18); P1.showPerson(); } |
1.7.6 类模板类外实现
#define_CRT_SECURE_NO_WARNINGS #include<iostream> #include<string> usingnamespacestd; template<classT1, classT2> classPerson{ public: Person(T1name, T2age); voidshowPerson(); public: T1mName; T2mAge; }; //类外实现 template<classT1, classT2> Person<T1, T2>::Person(T1name, T2age){ this->mName = name; this->mAge = age; } template<classT1, classT2> voidPerson<T1, T2>::showPerson(){ cout << "Name:" << this->mName << " Age:" << this->mAge << endl; } voidtest() { Person<string, int> p("Obama", 20); p.showPerson(); } intmain(){ test(); system("pause"); returnEXIT_SUCCESS; } |
1.7.7 类模板头文件和源文件分离问题
Person.hpp
#pragmaonce template<classT1,classT2> classPerson{ public: Person(T1name,T2age); voidShowPerson(); public: T1mName; T2mAge; }; template<classT1, classT2> Person<T1, T2>::Person(T1name, T2age){ this->mName = name; this->mAge = age; } template<classT1, classT2> voidPerson<T1, T2>::ShowPerson(){ cout << "Name:" << this->mName << " Age:" << this->mAge << endl; } |
main.cpp
#define_CRT_SECURE_NO_WARNINGS #include<iostream> usingnamespacestd; #include<string> #include"Person.hpp" //模板二次编译 //编译器编译源码逐个编译单元编译的 intmain(){ Person<string, int> p("Obama", 20); p.ShowPerson(); system("pause"); returnEXIT_SUCCESS; } |
结论: 案例代码在qt编译器顺利通过编译并执行，但是在Linux和vs编辑器下如果只包含头文件，那么会报错链接错误，需要包含cpp文件，但是如果类模板中有友元类，那么编译失败！
解决方案: 类模板的声明和实现放到一个文件中，我们把这个文件命名为.hpp(这个是个约定的规则，并不是标准，必须这么写).
原因：
l类模板需要二次编译，在出现模板的地方编译一次，在调用模板的地方再次编译。
lC++编译规则为独立编译。
1.7.8模板类碰到友元函数
#define_CRT_SECURE_NO_WARNINGS
#include<iostream>
usingnamespacestd;
#include<string>
template<classT1, classT2> classPerson;
//告诉编译器这个函数模板是存在
template<classT1, classT2> voidPrintPerson2(Person<T1, T2>& p);
//友元函数在类内实现
template<classT1, classT2>
classPerson{
//1. 友元函数在类内实现
friendvoidPrintPerson(Person<T1, T2>& p){
cout << "Name:" << p.mName << " Age:" << p.mAge << endl;
}
//2.友元函数类外实现
//告诉编译器这个函数模板是存在
friendvoidPrintPerson2<>(Person<T1, T2>& p);
//3. 类模板碰到友元函数模板
template<classU1, classU2>
friendvoidPrintPerson(Person<U1, U2>& p);
public:
Person(T1name, T2age){
this->mName = name;
this->mAge = age;
}
voidshowPerson(){
cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
}
private:
T1mName;
T2mAge;
};
voidtest01()
{
Person <string, int>p("Jerry", 20);
PrintPerson(p);
}
// 类模板碰到友元函数
//友元函数类外实现加上<>空参数列表，告诉编译去匹配函数模板
template<classT1 , classT2>
voidPrintPerson2(Person<T1, T2>& p)
{
cout << "Name2:" << p.mName << " Age2:" << p.mAge << endl;
}
voidtest02()
{
Person <string, int>p("Jerry", 20);
PrintPerson2(p);//不写可以编译通过，写了之后，会找PrintPerson2的普通函数调用，因为写了普通函数PrintPerson2的声明
}
intmain(){
//test01();
test02();
system("pause");
returnEXIT_SUCCESS;
}
1.8类模板的应用
设计一个数组模板类(MyArray),完成对不同类型元素的管理
#pragmaonce
template<classT>
classMyArray
{
public:
explicitMyArray(intcapacity)
{
this->m_Capacity = capacity;
this->m_Size = 0;
// 如果T是对象，那么这个对象必须提供默认的构造函数
pAddress = newT[this->m_Capacity];
}
//拷贝构造
MyArray(constMyArray & arr)
{
this->m_Capacity = arr.m_Capacity;
this->m_Size = arr.m_Size;
this->pAddress = newT[this->m_Capacity];
for (inti = 0; i < this->m_Size;i++)
{
this->pAddress[i] = arr.pAddress[i];
}
}
//重载[] 操作符arr[0]
T& operator [](intindex)
{
returnthis->pAddress[index];
}
//尾插法
voidPush_back(constT & val)
{
if (this->m_Capacity == this->m_Size)
{
return;
}
this->pAddress[this->m_Size] = val;
this->m_Size++;
}
voidPop_back()
{
if (this->m_Size == 0)
{
return;
}
this->m_Size--;
}
intgetSize()
{
returnthis->m_Size;
}
//析构
~MyArray()
{
if (this->pAddress != NULL)
{
delete[] this->pAddress;
this->pAddress = NULL;
this->m_Capacity = 0;
this->m_Size = 0;
}
}
private:
T * pAddress;//指向一个堆空间，这个空间存储真正的数据
intm_Capacity; //容量
intm_Size;// 大小
};
测试代码：
classPerson{
public:
Person(){}
Person(stringname, intage){
this->mName = name;
this->mAge = age;
}
public:
stringmName;
intmAge;
};
voidPrintMyArrayInt(MyArray<int>& arr){
for (inti = 0; i < arr.getSize(); i++){
cout << arr[i] << " ";
}
cout << endl;
}
voidPrintMyPerson(MyArray<Person>& personArr)
{
for (inti = 0; i < personArr.getSize(); i++){
cout << "姓名：" << personArr[i].mName << " 年龄： " << personArr[i].mAge << endl;
}
}
MyArray<int> myArrayInt(10);
for (inti = 0; i < 9; i++)
{
myArrayInt.Push_back(i);
}
myArrayInt.Push_back(100);
PrintMyArrayInt(myArrayInt);
MyArray<Person> myArrayPerson(10);
Personp1("德玛西亚", 30);
Personp2("提莫", 20);
Personp3("孙悟空",18);
Personp4("赵信", 15);
Personp5("赵云", 24);
myArrayPerson.Push_back(p1);
myArrayPerson.Push_back(p2);
myArrayPerson.Push_back(p3);
myArrayPerson.Push_back(p4);
myArrayPerson.Push_back(p5);