副标题#e#
在颠末艰巨的接头template metaprogramming很长时间后,返回到我们进修的开始。
在这一部门,我们来相识模板编程的更为恍惚的语法问题:在编译器没有充实的信息的环境下,奈何引导编译器举办阐明。在这里,我们将接头尺度容器顶用来消除歧义的“rebind”机制。同时,我们也将对一些潜在的模板编程技能举办热烈的接头。
甚至履历富厚的C++措施员,也经常被模板的巨大的语法所困扰。在所以模板语法中,我们首先要相识:消除编译器阐明的歧义,是最根基的语法狐疑。
Types of Names, Names of Types
让我们看看一个没有实现尺度容器的模板例子,这个例子很简朴。
template <typename T>
class PtrList {
public:
//...
typedef T *ElemT;
void insert( ElemT );
private:
//...
};
经常模板类嵌入Type names信息,这样,我们就可以通过正确的nested name 得到实例化的模板信息。
typedef PtrList<State> StateList;
//...
StateList::ElemT currentState = 0;
嵌入范例的ElenT答允我们可以,很容易的会见PtrList模板的所认可的元素范例。
纵然我们用State范例初始化PtrList,元素范例还将是State*。在其他一些环境下,PtrList 可以用指针元素实现。一个较量成熟的PtrList的实现,应该是可以跟着初始化的元素范例而变革的。利用nested type,可以辅佐我们封装PtrList,以免用户相识内部的实现。
下面尚有一个例子:
template <typename Etype>
class SCollection {
public:
//...
typedef Etype ElemT;
void insert( const Etype & );
private:
//...
};
SCollection的实现跟PtrList一样,遵守尺度定名的条款。遵守这些条款是有用的,这样我们就可以写出许多优雅的算法来利用这些容器(译注:像尺度模板库一样)。譬喻:可以写一个如下的算法:用适当的元素范例来填充这个容器数组。
template <class Cont>
void fill( Cont &c, Cont::ElemT a[], int len ) { // error!
for( int i = 0; i < len; ++i )
c.insert( a[i] );
}
#p#副标题#e#
蹩脚的编译器
很遗憾的是,在这里我们有一个语法错误。编译器不能识别Cont::ElemT这个type name。问题是在fill()的上下文中,没有足够的信息让编译器知道ElemT是一个type name。在尺度中划定,在这种环境下,认为nested name 不是type name。 此刻方才开始,假如你没有领略,没干系。我们来看看在差异的上下文中,编译器所得到的信息。首先,让我们来看看在没有模板的class的环境:
class MyContainer {
public:
typedef State ElemT;
//...
};
//...
MyContainer::ElemT *anElemPtr = 0;
由于编译器可以检测到MyContainer class的上下文确定有个ElemT的成员范例,从而可以确认MyContainer::ElemT确实是一个type name。在实例化的模板类中,其实,也跟这种环境一样简朴。
typedef PtrList<State> StateList;
//...
StateList::ElemT aState = 0;
PtrList<State>::ElemT anotherState = 0;
对付编译器来说,一个实例化的模板类跟一个普通的类一样。在存储PtrList<State>的nested name 和在MyContainer中是一样的,没有什么不同。在其他环境下,编译器也是这样查抄上下文来看ElemT是不是type name。然而,当我们进入template的上下文后,工作就变得巨大了。因为在这,没有充实的精确信息。思量下面的措施片段:
template <typename T>
void aFuncTemplate( T &arg ) {
...T::ElemT...
当编译器碰着T::ElemT,它不知道这是什么。从模板的申明中,编译器知道,T是一个范例名。它通过::运算符也能揣摩出T是一个范例名。可是,这就是所有编译器知道的。因为,这里没有关于T的更多的信息。譬喻:我们可以或许用PtrList来挪用一个模板函数,在这里,T::ElemT将是一个Type name。
PtrList<State> states;
//...
aFuncTemplate( states ); // T::ElemT is PtrList<State>::ElemT
But suppose we were to instantiate aFuncTemplate with a different type?
struct X {
double ElemT;
//...
};
X anX;
//...
aFuncTemplate( anX ); // T::ElemT is X::ElemT
在这个例子中,T::ElemT是数据范例,不是type name。编译器将怎么办呢?在尺度中划定,在这种环境下,编译器将认为nested name 不是type name。在将在上述fill()模板函数中导致一个语法错误。
Clue In the Compiler
为了处理惩罚这种环境,我们必需清晰的提示编译器:
这个nested name 是type name。如下:
template <typename T>
void aFuncTemplate( T &arg ) {
...typename T::ElemT...
#p#分页标题#e#
在这里,我们利用要害字typename 来汇报编译器后头随着的name,是type name。这样使得编译器可以正确的阐明template。留意:我们汇报编译器:ElemT而不是T,是Type name。虽然,编译器也可以或许知道T也是type name。同样,假如我们这样写:
typename A::B::C::D::E
这样,我们就相当于汇报编译器,E是type name。虽然,假如模板函数传入的范例不满意template解析要求的话,会导致一个编译时刻的编译错误。
struct Z {
// no member named ElemT...
};
Z aZ;
//...
aFuncTemplate( aZ ); // error! no member Z::ElemT
aFuncTemplate( anX ); // error! X::ElemT is not a type name
aFuncTemplate( states ); // OK. PtrList<State>::ElemT is a type name
此刻,我们可以重写fill()模板函数,
void fill( Cont &c, typename Cont::ElemT a[], int len ) { // OK
for( int i = 0; i < len; ++i )
c.insert( a[i] );
}
Gotcha: Failure to Employ typename with Permissive Compilers
留意:
利用typename 要求 嵌入 type name,假如编译器不能获得足够的信息的话,在模板的外部利用typename是犯科的。
PtrList<State>::ElemT elem; // OK
typename PtrList<State>::ElemT elem; // error!
在模板的上下文中,这是很常见的错误。思量一个在模板,在它内部实现,在编译时刻,从两个范例中选出一个,譬喻:
Select<cond,int,int *>::R r1; // OK
typename Select<cond,int,int *>::R r2; // error!
//...
}
由于编译器可以得到所有模板参数的信息,因此,甚至不需要在Select前写typename。假如,用模板重写f(),我们就可以利用typename。
template <typename T>
void f() {
Select<cond,int,int *>::R r1; // #1: OK, typename not required
typename Select<cond,int,int *>::R r2; // #2: superfluous
Select<cond,T,T *>::R r3; // #3: error! need typename
typename Select<cond,T,T *>::R r4; // #4: OK
//...
}
在环境2中,typename,可以不写,这样是可以的。
最有问题的是环境3,许多编译器都能察觉这个错误,将把这个嵌入的R表明为type name(简直它是一个type name,可是没有但愿它表明为type name)今后,假如,这段代码呈此刻尺度编译器上,那么会被查堕落误的。因为这个原因,当你用C++模板编程,假如你必需利用非尺度编译器的,你最好利用高级尺度编译器,来查抄你的代码。
Intermezzo: Expanding Monostate Protopattern
在模板问题上,我们先搁浅一下,让我们看看搜索技能。 当我们想制止Monostate经常是Singleton的很好替代技能。当为了制止全局变量带来的贫苦时,Monostate是Singleton的很好替代品。
class Monostate {
public:
int getNum() const { return num_; }
void setNum( int num ) { num_ = num; }
const std::string &getName() const { return name_; }
private:
static int num_;
static std::string name_;
};
就像Singleton一样,Monostate 提供工具的简朴copy,不像典范的Singleton,这种分享机制不是由结构函数实现的。而是通过存储静态成员。留意:Monostate差异于传统的利用静态成员机制,传统的步伐是通过静态成员函数来存储静态成员变量。 Monostate提供非静态成员函数来存储静态成员变量。(译注:好要领,我们来看作者怎么实现的)
Monostate m1;
Monostate m2;
//...
m1.setNum( 12 );
cout << m2.getNum() << endl; // shift 12
每一个差异范例的Monostate分享沟通的状态。Monostate没有利用任何非凡的语法,不像Singleton的实现。
Singleton::instance().setNum( 12 );
cout << Singleton::instance().getNum() << endl;
Expanding Monostate
假如我们想在Monostate中添加新的静态成员,那么该怎么实现?抱负的环境是不添加操纵不需要改变源代码,甚至不要重编译不相关的代码。让我们来看看奈何利用template来实现这个任务的。
class Monostate {
public:
template <typename T>
T &get() {
static T member;
return member;
}
};
留意:这个模板函数可以在编译时,按需要初始化,很遗憾的,它不能是虚拟函数。这个版本的Monostate为分享静态成员,实现了"lazy creation" 。
Monostate m;
m.get<int>() = 12; // create an int member
Monostate m2;
cout << m2.get<int>(); // access previously-created member
m2.get<std::string>() = "Hej!" // create a string member
留意: 不像传统的Singleton的"lazy creation"那样,这个"lazy creation"浸染于编译时刻,而不是运行时刻。
Indexed Expanding Monostate
#p#分页标题#e#
这个步伐其实还很不抱负,至少假如用户想有多个分享的非凡范例的成员,那么又该怎么办?一种改进的步伐是给模板成员函数添加一个参数“index”。
class IndexedMonostate {
public:
template <typename T, int i>
T &get();
};
template <typename T, int i>
T &IndexedMonostate::get() {
static T member;
return member;
}
此刻,我们可以拥有多个非凡范例的成员了,可是这个接口还可以越发完善。
IndexedMonostate im1, im2;
im2.get<int,1066>() = 12;
im2.get<double,42>() = im2.get<int,1066>()+1;
Named Expanding Monostate
我们所需要的是记任命户的利用Monostate成员的范例。这个范例也是为模板函数的包装的范例和static成员的实际范例。
template <typename T, int n>
struct Name {
typedef T Type;
};
这个Name类看上去很简朴,可是它已经足够满意要求。
typedef Name<int,86> grossAmount;
typedef Name<double,007> percentage;
此刻我们可以可读范例,并且还可以把成员范例和index绑定在一起。留意:这index对应的实际数值不是实质性的,只要[type,index] 是独一的。一个定名的Monostate假定成员的范例可以或许从它的初始化范例解压。
class NamedMonostate {
public:
template <class N>
typename N::Type &get() {
static typename N::Type member;
return member;
}
};
这个提高用户接口的技能是没有牺牲本来技能的简朴性和利便性(留意:typename是汇报嵌入的N::Type是一个type name)。
可以这样利用:
NamedMonostate nm1, nm2;
nm1.get<grossAmount>() = 12;
nm2.get<percentage>() = nm1.get<grossAmount>() + 12.2;
cout << nm1.get<grossAmount>() * nm2.get<percentage>() << endl;
最后,我们可以修改接口来利用Monostate。
class GSNamedMonostate {
public:
template <typename N>
void set( const typename N::Type &val ) {
// This const_cast is actually safe,
// since we are always actually getting
// a non-const object. (Unless N::Type is
// const, then you get a compile error here.)
const_cast<typename N::Type &>(get()) = val;
}
template <typename N>
const typename N::Type &get() const {
static typename N::Type member;
return member;
}
};
这是原型模式(Protopattern)吗?
其实,像我们方才开始提到的一样,这是搜索技能。同样,我们没有权利挪用这样的模式。一个设计模式是包装了乐成的实际成就的。这个"protopattern"凡是应用在上下文中可以察觉的技能,因此,不能被应用于越发遍及的“pattern”软件中。由于我们不能指出它的乐成之处所,所以,我们只能只管扩展monostate这个模式。
Template Names in Templates
让我们回到阐明模板的编译器问题上来吧。编译器阐明的困难,不只只有嵌入type names,并且,我们还经常见到嵌入 template names 雷同的问题。挪用一个类,或类模板必需有一个这样的成员。这个成员是一个类,或模板函数。
譬喻:一个利用模板成员函数的扩展Monostate可以按需要这样初始化:
typedef Name<int,86> grossAmount;
typedef Name<double,007> percentage;
GSNamedMonostate nm1, nm2;
nm1.set<grossAmount>( 12 );
nm2.set<percentage>( nm1.get<grossAmount>() + 12.2 );
cout << nm1.get<grossAmount>() * nm2.get<percentage>() << endl;
在上面的代码中,编译器在查抄模板get不会遇到任何坚苦。 个中,nm1和nm2是GSNamedMonostate的范例名,编译器可以在类内里查询get和set的范例。
然而,思量写这样一个优雅的函数:它可以或许用来移置扩展的Monostate object。
template <typename M>
void populate() {
M m;
m.get<grossAmount>(); // syntax error!
M *mp = &m;
mp->get<percentage>(); // syntax error!
}
又一次,问题出在编译器不知道M足够的信息,除了,知道它是type name外。出格是,假如没有足够的get<>信息的话,编译器会认为它不是type,不是模板名。因此,m.get<grossAmount>()的中括号被表明为大于号,和小于号,而不是模板参数列表。
这种环境下,办理步伐是要汇报编译器<>是模板参数列表,而不是其他的操纵名。
#p#分页标题#e#
template <typename M>
void populate() {
M m;
m.template get<grossAmount>(); // OK
M *mp = &m;
mp->template get<percentage>(); // OK
}
是不是不行思议啊,就像阐明利用typename一样,这种template非凡的用法,仅在须要的环境下,才气利用。
Hints For Rebinding Allocators
我们也遇到嵌入模板类的同样的阐明问题,在STL allocator的实现,就是这样的经典例子。
template <class T>
class AnAlloc {
public:
//...
template <class Other>
class rebind {
public:
typedef AnAlloc<Other> other;
};
//...
};
这个模板类AnAlloc中就有嵌入的name,而这个name自己就是一个模板类。这是利用STL的框架来建设allocators,就像allocators为一个容器用差异的数据范例初始化一样。譬喻:
typedef AnAlloc<int> AI; // original allocator allocates ints
typedef AI::rebind<double>::other AD; // new one allocates doubles
typedef AnAlloc<double> AD; // legal! this is the same type
也许,这样看起来是有些多余。可是利用rebind机制可以答允我们用现存的allocator为差异的数据范例事情,并且不需要知道当前的allocator范例和要allocate数据范例。
typedef SomeAlloc::rebind<ListNode>::other NewAlloc;
假如SomeAlloc要为STL的allocators提供利便的话,它要有嵌入的rebind 模板类。本质上说:“我们不要知道allocator的范例,也不要知道分派范例,可是,我想要一个像allocates ListNodes一样的allocator”。
在模板中经常忽视这种事情,直到template 初始化后,变量的范例和值才气确定。思量STL各类编译List容器的实现,我们的模板列表有两个模板参数,一个元素范例(T)和allocator type(A)。(像尺度容器,我们list提供缺省的allocator )。
template < typename T, typename A = std::allocator<T> >
class OurList {
struct Node {
//...
};
typedef A::rebind<Node>::other NodeAlloc; // error!
};
作为典范基于lists基本的容器,我们的list实际上不分派和操纵元素Ts。而是,分派和操纵T范例的容器。这种环境,就是我们前面所报告的。我们有allocator,它知道奈何分派T范例的工具,可是,我们想分派OurList<T,A>::Node。然而,当我们实验这么rebind的时候,我们会呈现语法错误。 这个问题再一次是因为编译器没有A范例足够的信息。因此,编译器认为嵌入的rebind name不是模板name,同时,<>被表明为大于,小于操纵。可是,这只是我们问题的开始。就算编译器可以或许知道rebind 是template name,它也会认为不是type name。因此,必需这么写typedef。
typedef typename A::template rebind<Node>::other NodeAlloc;
要害字template汇报编译器这个rebind是模板名,要害字typename汇报编译器整个指向一个type name,很简朴吧。
参考资料和留意事项:
[1]这样的接口并不老是一个好的主意。参考 Gotcha #80: Get/Set Interfaces in C++ Gotchas (Addison-Wesley, 2003). [2]事实上,你也许可以不这样做,尽量从哲学的角度来说,populate是一个很有意思的模板函数,它是为许多模板在编译时刻初始化处事的。这样,不需要在编译时刻挪用函数了(译注:虚拟函数就是运行时刻初始化)然而,假如函数没有挪用,它将不被初始化,这种初始化也不将完成。其他可行的要领就是获得函数的地点,而不是挪用函数,可能作一个明明的初始化,这样,假如,函数在运行时刻不需要,它也会存在。 [3]假如你不熟悉STL的allocator,你不要担忧,在今后的接头中,不需要对它熟悉。allocator就是一个类罢了,只不外,它是用来为STL容器打点内存的。Allocators是模板类的典范的实现。About the Author
Stephen C. Dewhurst (<www.semantics.org>) is the president of Semantics Consulting, Inc., located among the cranberry bogs of southeastern Massachusetts. He specializes in C++ consulting, and training in advanced C++ programming, STL, and design patterns. Steve is also one of the featured instructors of The C++ Seminar (<www.gotw.ca/cpp_seminar>
