模板的一些高级主题

十一、模板与继承

1、当从模板类派生出子类时必须注意的是：子类并不会从通用的模板基类继承而来，只能从基类的某一实例继承而来。

这样的话就有以下几种继承方式：

 

a、基类是模板类的一个特定实例版本，比如template<class T> class B : public A<int>{};

 

b、基类是一个和子类相关的一个实例，比如template<class T> class B : public A<T>{};

这时当实例化一个子类B的时候,基类就相应的被实例化为一个和子类相同的实例版本，比如B<int> m；模板类B被实例化为int 版本，这时基

类A也相应的被实例化为int版本。

 

c、template<class T> class B : public T  这种用法最普遍,也最难 ,ATL中广泛使用此法.属于基于模板的复用,和基于继承的复用不同.它非常巧妙的用了模板的特性模拟了C++的多态,而不是采用虚函数.

 

d、如果基类是一个特定的实例的版本，这时子类可以不是一个模板，比如class B : public A<int>{}。

 

//模板与继承的示例

#include <iostream>

#include <string>

using std::string;

using std::cout;

using std::endl;

//模板与继承的示例

template<class T>

class A

{

public:

void ga()

{

cout<<"class A "<<typeid(T).name()<<endl;

}

};

//以下是几种继承方式

template<class T1> class B : public A<int>{public: void gb(){cout<<"class B "<<typeid(T1).name()<<endl;}};

template<class T2> class C : public A<T2>{public: void gb(){cout<<"class C "<<typeid(T2).name()<<endl;}};

//template<class T3> class D: public A<T>{} //错误，模板形参T在这里是不可见的说明符。错误原因在于，继承并不会从通用的基类中继承而来，只能是从某一特定的基类中继承而来。

class E: public A<double>{}; //从特定实例继承时子类可以是一般的类

void main()

{

B<double> m;

m.ga(); //输出class A int;

m.gb(); //输出class B double;

C<double> mc;

mc.ga(); //输出class A double

mc.gb(); //输出class C double

} 

 

 

十二、模板中的关键字typename和class的区别

1、首先typename是一个较新的关键字，而class是比较老的关键字， 在类模板的声明中使用哪个都是一样的。

2、必须使用typename 关键字的情况：当有一个模板，且模板的类型形参和某一个类名同名，而且这个同名的类中又有

一个嵌套类的时候就要使用关键字typename了，比如有类class T{public: class A{};}; 则template<class T> class B{T::A

m;};这时的语句就会出错，因为模板类B 无法区别出T::A 表示的是一个类型还是一个数据成员，在C++里面默认情

况下是一个数据成员，在这里的语句T::A m就会出错，会出现m前缺少类型说明符的错误。要使该式正确就必须在

T::A前加上typename关键字以说明T::A表示的是一个类型。即template<class T> class B{typename T::A m;}这样就正

确地声明了一个类T 的嵌套类A 的对象m。当然如果模板的类型形参和那个类名不同名时不会出现这种错误，比如

把嵌套类B的外围类的类名改为D，则在模板类B中的语句D::B m;将是正确的语句。

 #include "iostream"

using namespace std;

//关键字typename 和class 的区别的示例

class T

{

public:

static int e;

class B

{

public:

void gb()

{

cout<<"class B"<<endl;

}

};

}; //定义一个带有嵌套的类T。

int T::e = 3;

template<class T1> class A

{

public:

T::B a;

}; //模板形参与带有嵌套的类T不同名，所以这里的语句T::B a是正确的。当然在前面加上

//typename关键字也不会出错。

template<class T>

class D

{

public:

typename T::B b;

}; //模板形参与带有嵌套类的类名同名，在语句T::B b;前必须加上typename以指

//定这里的嵌套类B是一个类型而不是一个表达式。

template<class T>

class F

{

public:

void g()

{

int a = T::e;

cout<<a<<endl;

}

};//这个范例可以看出如果不在T::e前加typename则系统

//  默认表示的是e是一个数据成员，而不是一个类型。

int main()

{

A<int> ma;

ma.a.gb(); //输出class B

D<int> md;

md.b.gb(); //输出class B

F<int> mf;

mf.g();//输出数字3，在这里可以清楚的看到T::e默认表示的是一个数据成员而不是类型。

}