文章目录
第九章 函数模板和类模板
第一节 函数模板
设计程序中的函数时，可能会遇到函数中参数的类型有差异，但需要实现的功能类似的情形。函数重载可以处理这种情形。重载函数的参数表中，可以写不同类型的参数，从而可以处理不同的情形。
一、函数模板的概念
- 为了提高效率，实现代码复用，C++提供了一种处理机制，即使用函数模板。
- 函数在设计时并不使用实际的类型，而是使用虚拟的类型参数。这样可以不必为每种不同的类型都编写代码段。当用实际的类型来实例化这种函数时，将函数模板与某个具体数据类型连用。编译器将以函数模板为样板，生成一个函数，即产生了模板函数，这个过程称为函数模板实例化。
- 函数模板实例化的过程由编译器完成。程序设计时并不给出相应数据的类型，编译时，由编译器根据实际的类型进行实例化。
二、函数模板的示例
1、函数模板中含一个参数类型
#include <iostream>
using namespace std;
template<typename T>
T abs(T x)
{
return x<0 ? -x : x;
}
int main()
{
int n=5,m=10;
double d = -.5;
float f =3.2;
cout<<n<<"的绝对值是："<<abs(n)<<endl;
cout<<m<<"的绝对值是："<<abs(m)<<endl;
cout<<d<<"的绝对值是："<<abs(d)<<endl;
cout<<f<<"的绝对值是："<<abs(f)<<endl;
return 0;
}
在主函数中，调用abs(n)时，编译器根据实参n的类型int，推导出模板中的类型参数T为int，然后实例化函数模板，生成函数模板abs的一个实例。
int abs (int x)
{
return x < 0 ? -x : x;
}
这个实例即是模板函数。
当调用abs(d)时，根据实参d的类型double，又实例化一个新的函数。
double abs (double x)
{
return x < 0 ? -x : x;
}
这是另一个模板函数。
实际上，函数模板不是一个具体的函数，编译器不能为其生成可执行代码。定义函数模板后只是一个对函数功能框架的描述，当它具体执行时，将根据传递的实际参数决定其功能。
- 虽然函数模板的使用形式与函数类似，但二者有本质的区别，主要表现在以下3个方面。
- 1）函数模板本身在编译时不会生成任何目标代码，只有当通过模板生成具体的函数实例时才会生成目标代码。
- 2）被多个源文件引用的函数模板，应当连同函数体一同放在头文件中，而不能像普通函数那样只将声明放在头文件中。
- 3）函数指针也只能指向模板的实例，而不能指向模板本身。
#include <iostream>
using namespace std;
template<class T>
void Swap(T &x,T &y)
{
T temp = x;
x=y;
y=temp;
};
class myDate
{
private:
int year,month,day;
public:
myDate();
myDate(int,int,int);
void printDate()const;
};
myDate::myDate():year(1970),month(1),day(1){};
myDate::myDate(int y, int m, int d):year(y),month(m),day(d){};
void myDate::printDate() const
{
cout<<year<<"/"<<month<<"/"<<day<<endl;
return;
};
int main()
{
int n=1,m=2;
//编译器自动生成void Swap(int &,int &)函数
Swap(n,m);
cout<<n<<" "<<m<<endl;
double f=1.2,g=2.3;
//编译器自动生成void Swap(double &,double &)函数
Swap(f,g);
cout<<f<<" "<<g<<endl;
myDate d1,d2(2000,1,1);
//编译器自动生成void Swap(myDate &,myDate &)函数
Swap(d1,d2);
d1.printDate();
d2.printDate();
return 0;
}
2、函数模板中含多个参数类型
函数模板中还可以带多个类型参数。例如，下面这个函数模板的写法是合法的。
template <class T1,class T2>
void print(T1 arg, T2 arg2)
{
cout<<arg1<<"，"<<arg2<<endl;
}
三、函数或函数模板调用语句的匹配顺序
- 函数与函数模板也是允许重载的。在函数和函数模板名字相同的情况下，一条函数调用语句到底应该被匹配成对哪个函数或哪个模板的调用呢？C++编译器遵循以下先后顺序。
- ① 先找参数完全匹配的普通函数（不是由模板实例化得到的模板函数）。
- ② 再找参数完全匹配的模板函数。
- ③ 然后找实参经过自动类型转换后能够匹配的普通函数。
- ④ 如果上面的都找不到，则报错。
第二节 类模板
一、类模板概念
- 通过类模板，可以实例化一个个的类。继承机制也是在一系列的类之间建立某种联系，这两种涉及多个类的机制是有很大差异的。类是相同类型事物的抽象，有继承关系的类可以具有不同的操作。而模板是不同类型的事物具有相同的操作，实例化后的类之间没有联系，相互独立。
- 声明类模板的一般格式如下：
template <模板参数表>
class 类模板名
{
类体定义
}
- 其中，“模板参数表”的形式与函数模板中的“模板参数表”完全一样。类体定义与普通类的定义几乎相同，只是在它的成员变量和成员函数中通常要用到模板的类型参数。
- 类模板的成员函数既可以在类体内进行说明，也可以在类体外进行说明。如果在类体内定义，则自动成为内联函数。如果需要在类模板以外定义其成员函数，则要采用以下格式。
template <模板参数表>
返回类型名 类模板名<模板参数标识符列表>::成员函数名(参数表)
{
函数体
}
- 类模板声明本身并不是一个类，它说明了类的一个家族。只有当被其他代码引用时，模板才根据引用的需要生成具体的类。
不能使用类模板来直接生成对象，因为类型参数是不确定的，必须先为模板参数指定“实参”，即模板要“实例化”后，才可以创建对象。也就是说，当使用类模板创建对象时，要随类模板名给出对应于类型形参或普通形参的具体实参，格式如下：
类模板名 <模板参数表> 对象名1,…,对象名n;
或是
类模板名 <模板参数表> 对象名1(构造函数实参),…,对象名构造函数实参);
编译器由类模板生成类的过程称为类模板的实例化。由类模板实例化得到的类称为模板类。
要注意的是，与类型形参相对应的实参是类型名。
二、类模板示例
- 二元组是常用的一种结构。可以定义两个值的二元组，如平面坐标系下点的横、纵坐标组成的二元组。还可以定义两个字符串的二元组，如字典中单词与释义组成的二元组。还可以定义学生姓名及其成绩的二元组。二元组的例子非常多，不胜枚举。
- 如果要定义二元组的类，则需要根据组成二元组的类型定义很多不同的类。现在可以使用类模板来解决问题。
#include <iostream>
using namespace std;
template<class T>
class TestClass
{
public:
T buffer[10];
T getData(int j);
};
template<class T>
T TestClass<T>::getData(int j)
{
return *(buffer+j);
};
int main()
{
//char取代T，从而实例化为一个具体的类
TestClass<char> ClassInstA;
int i;
char cArr[6]="abcde";
for(i=0;i<5;i++)
{
ClassInstA.buffer[i]=cArr[i];
};
for(i=0;i<5;i++)
{
char res = ClassInstA.getData(i);
cout<<res<<" ";
};
cout<<endl;
//实例化为另外一个具体的类
TestClass<double>ClassInstF;
double fArr[6]={1.11,2.22,3.33,4.44,5.55,6.66};
for(i=0;i<6;i++)
{
ClassInstF.buffer[i]=fArr[i]-1.11;
}
for(i=0;i<6;i++)
{
double res = ClassInstF.getData(i);
cout<<res<<" ";
}
cout<<endl;
return 0;
}
#include <iostream>
using namespace std;
template<int i>
class TestClass
{
public:
//使buffer的大小可变化，但其类型则固定为int
int buffer[i];
int getData(int j);
};
template<int i>
int TestClass<i>::getData(int j)
{
return *(buffer+j);
};
int main()
{
TestClass<6> ClassInstF;
int i;
double fArr[6]={1.11,2.22,3.33,4.44,5.55,6.66};
for(i=0;i<6;i++)
{
ClassInstF.buffer[i]=fArr[i]-1;
}
for(i=0;i<6;i++)
{
double res = ClassInstF.getData(i);
cout<<res<<" ";
}
cout<<endl;
}
三、类模板与继承
- 类之间允许继承，类模板之间也允许继承。具体来说，类模板和类模板之间、类模板和类之间可以互相继承，它们之间的常见派生关系有以下4种情况：
- ① 普通类继承模板类。
- ② 类模板继承普通类。
- ③ 类模板继承类模板。
- ④ 类模板继承模板类。
- 根据类模板实例化的类即是模板类。
1、普通类继承模板类。
#include <iostream>
using namespace std;
template<class T>
class TBase
{
T data;
public:
void print()
{
cout<<data<<endl;
}
};
//从模板继承，普通类
class Derived:public TBase<int>{};
int main()
{
Derived d; //普通派生类的对象
d.print(); //调用类模板中的成员函数
return 0;
}
2、类模板继承普通类。
#include <iostream>
#include <string>
using namespace std;
class TBase
{
int k;
public:
void print(){ cout<<"TBase::"<<k<<endl; };
};
template<class T>
class TDerived:public TBase
{
T data;
public:
void setData(T x){ data=x; };
void print()
{
TBase::print();
cout<<"TDerived::"<<data<<endl;
}
};
int main()
{
TDerived<string> d;
d.setData("2019");
d.print();
return 0;
}
3、类模板继承类模板。
#include <iostream>
#include <string>
using namespace std;
template <class T>
class TBase
{
T data1;
public:
void print(){ cout<<"TBase::"<<data1<<endl; };
};
template<class T1,class T2>
class TDerived:public TBase<T1>
{
T2 data2;
public:
void print()
{
TBase<T1>::print();
cout<<"TDerived::"<<data2<<endl;
}
};
void main()
{
//类模板实例化，并声明对象
TDerived<int,int>d;
d.print();
TDerived<string,string>d2;
d2.print();
return;
}
4、类模板继承模板类。
#include <iostream>
#include <string>
using namespace std;
template <class T>
class TBase
{
T data1;
public:
void print(){ cout<<"TBase::"<<data1<<endl; };
};
//类模板 继承与 模板类
template<class T2>
class TDerived:public TBase<int>
{
T2 data2;
public:
void print()
{
TBase<int>::print();
cout<<"TDerived::"<<data2<<endl;
}
};
int main()
{
TDerived<int> d;
d.print();
TDerived<string> d2;
d2.print();
}
扫一扫
746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
