动机
1.
下面有一个模板函数,假设一个动物收容组织提供了它,他们接受所有无家可归的可怜的小动物,于是他们向外界提供了一个函数接受注册。函数看起来像这样:
template<class
void
{
};
约定所有的动物类(如class
struct
struct
于是,所有狗类都必须像这样:
class
{
}
然后,动物收容组织可以在内部提供对猫狗分开处理的函数,像这样:
template<class
void
{...}
template<class
void
{...}
于是先前的Accept函数可以改写如下:
template<class
void
{
1
}
所有型别推导,函数重载,都在编译期完成,你几乎不用耗费任何运行期成本(除了创建dog_tag,cat_tag临时对象的成本,然而经过编译器的优化,这种成本可能也会消失)就拥有了可读性和可维护性高的代码。“但是,等等!”你说:“traits在哪?”,typename
于是1处的代码可以写成Accept(animal,typename
2.
通常为了提高效率,为某种情况采取特殊的措施是必要的,例如STL里面的copy,原型像这样:
template<typename
IterOut
}
copy_opt有两个版本,其中一个是针对如基本型别的数组作优化的,如果拷贝发生在char数组间,那么根本用不着挨个元素赋值,基于数组在内存中分布的连续性,可以用速度极快的memmove函数来完成。ptr_category有很多重载版本,对可以使用memmove的情况返回一个空类如scalar_ptr的对象以激发函数重载。其原始版本则返回空类non_scalar_ptr的对象。copy_opt的两个版本于是像这样:
template<typename
IterOut
template<typename
IterOut
其实通常为了提高效率,还是需要分派。
3.
这或许令人费解,原来不能通过编译的代码,经过traits的作用就能编译了吗?是的,考虑std::pair的代码(为使代码简洁,忽略大部分):
template
struct
{
};
这里可以使用一个traits(boost库里面的名字为add_reference)来避免这样的错误。这个traits内含一个typedef,如果add_reference<T>的T为引用,则typedef
pair(add_reference<const
这对所有的型别都能通过编译。
Boost库中的Traits
Boost中的Traits十分完善,可分为几大类:1.
由于其中一些traits只是简单的模板偏特化,故不作介绍,本文仅介绍一些技术性较强的traits。由于traits的定义往往重复代码较多,所以必要时本文仅剖析其底层机制。所有源码均摘自相应头文件中,为使源码简洁,所有的宏均已展开。由于traits技巧与编译平台息息相关,某些平台可能不支持模板偏特化。这里我们假设编译器是符合C++标准的。在我的VC7.0上,以下代码均通过编译并正常工作。
1.
is_array<>(boost/type_traits/is_array.hpp)
定义
template<typename
template<typename
注解
C++标准允许整型作为模板参数,上面的N就是这样。这也说明出现在模板偏特化版本中的模板参数(在本例中为typename
is_array<int
is_array<int>::value
is_class<>(.../is_class.hpp)
定义
};
template<typename
struct
{
};
注解
::boost::type_traits::yes_type为一个typedef:
::boost::type_traits::no_type为一个struct:
他们一般被用作重载函数的返回值型别,这样通过检查返回值型别的大小就知道到底调用了哪个函数,他们被定义在boost/type_traits/detail/yes_no_type.hpp中。
is_class_impl中有两个static函数,第一个函数仅当模板参数U是类时才能够被具现化,因为它的参数类型是void(U::*)(void),即指向成员函数的指针。第二个函数具有不定量任意参数列表,C++标准说只有当其它所有的重载版本都不能匹配时,具有任意参数列表的重载版本才会被匹配。所以,如果T为类,则void
现在注意3处的表达式sizeof(is_class_tester<T>(0))==sizeof(boost::type_traits::yes_type)。按照以上的推论,如果T为类,is_class_tester<T>(0)实际调用第一个重载版本,返回yes_type,则表达式评估为true。如果T不是类,则is_class_tester<T>(0)调用第二个重载版本,返回no_type,则表达式评估为false。这正是我们想要的。一个值得注意的地方是:在sizeof的世界里,没有表达式被真正求值,编译器只推导出表达式的结果的型别,然后给出该型别的大小。对于sizeof(is_class_tester<T>(0))编译器实际并不调用函数的代码来求值,而只关心函数的返回值型别。所以声明该函数就够了。另一个值得注意之处是is_class_tester的两个重载版本都用了模板函数的形式。第一个版本用模板形式的原因是如果不那样做,而是这样static
“等等!”你意识到了一些问题:“模板函数的调用可以不用显式指定模板参数!”好吧,也就是说你试图这样写:
然后在3标记的那一行这样调用:is_class_tester(0)(原来是is_class_tester<T>(0)),是的,我得承认,这的确构成了函数重载的条件,也的确令人欣喜的通过了编译,然而结果肯定不是你想要的!你会发现对所有型别is_class<ANYTYPE>::value现在都是0。也就是说,编译器总是调用is_class_tester(..);这是因为,当调用的函数的所有重载版本中有一个或多个为模板时,编译器首先要尝试进行模板函数具现化而非重载决议,而在尝试具现化的过程中,编译器会进行模板参数推导,0的型别被编译器推导为int(0虽然可以赋给指针,但0的型别不可能被推导为指针型别,因为指针型别可能有无数种,而事实上C++是强类型语言,对象只能属于某一种型别),而第一个函数的参数型别void
以上所将的利用函数重载来达到某些目的的技术在type_traits甚至整个Boost库里多处用到。
初级型别分类还有:is_void<>,is_integral<>,is_float<>,is_pointer,is_reference<>,is_union<>,is_enum<>,
is_function<>。请参见Boost提供的文档。
2.次级型别分类
is_member_function_pointer<>(.../is_member_function_pointer.hpp)
定义(.../detail/is_mem_fun_pointer_impl.hpp)
};
struct
struct
.etc.
template<class
struct
{
注解
假设你有一个类X,你这样判断:is_mem_function_pointer<int
is_mem_function_pointer的模板参数class
,随后编译器寻找后者的偏特化版本中最佳匹配项为is_mem_fun_pointer_impl<R(T::*)(T0)>其中R=int,
T=X,T0=int。该偏特化版本的value=true;
次级型别分类还有:is_arithmetic<>,is_fundamental<>,is_object<>,is_scalar<>,is_compound<>。请参见
Boost提供的文档。
3.型别属性 is_empty<>(.../is_empty.hpp) 定义 template struct empty_helper_t1 : public T //如果T是空类,那么派生类的大小就是派生部分的大小 { //即sizeof(int)*256 empty_helper_t1(); int i[256]; }; // struct empty_helper_t2 { int i[256]; }; //大小为sizeof(int)*256 //通过比较以上两个类的大小可以判断T是否为空类,如果它们大小相等则T为空类。反之则不为空 //这里一个值得注意的地方是:若定义一个空类E,则sizeof(E)为1(这一个字节是用于在内存中唯一 //标识该类的不同对象。如果sizeof(E)为0,则意味着不同的对象在内存中的位置没有区别,这显然有 //违直观)。然而如果有另一个非空类继承自E,那么这一个字节的内存就不需要。也就是说派生类的 //大小等于派生部分的大小而非多出一个字节。 template struct empty_helper //这个辅助类的作用是:如果T不是类则使用该缺省版本 { //如果T是类则使用下面的偏特化版本。而判断T是否为类的工作则由上面讲过 static const bool value = false; //的is_class<>traits来做。 }; template struct empty_helper { 5 static const bool value = (sizeof(empty_helper_t1) == sizeof(empty_helper_t2)); }; template struct is_empty_impl { typedef typename remove_cv::type cvt; //remove_cv将T的const volatile属性去掉,这是因为在 //public 后面不能跟const volatile T。 static const bool value = (::boost::type_traits::ice_or< //ice_or<>相当于逻辑或 4 ::boost::detail::empty_helper<cvt,::boost::is_class::value>::value //cvt作为基类,不能有cv修饰符 , BOOST_IS_EMPTY(cvt) //该宏被简单地定义为false,但对结果无影响 >::value); }; 注解在标记4处,如果is_class::value为true(即T为类)则empty_helper<cvt,is_class::value>::value实际决议为empty_helper,这将采用偏特化版本,转到5,则结论出现。否则T不是类,则采用缺省版本,结果value为false。 is_polymorphic<>(.../is_polymorphic.hpp) is_plymorphic<>基于一个基本事实:一个多态的类里面会有一个虚函数表指针(一般称为vptr),它指向一个虚函数表(一般称为vtbl)。后者保存着一系列指向虚函数的函数指针以及运行时类型识别信息。一个虚函数表指针通常占用4个字节(32寻址环境下的所有指针都占用4个字节)。反之,如果该类不是多态,则没有这个指针的开销。基于这个原理,我们可以断定:如果类X不是多态类(没有vtbl及vptr),则如果从它派生一个类Y,Y中仅含有一个虚函数,这会导致sizeof(Y)>sizeof(X)(这是因为虚函数的首次出现导致编译器必须在Y中加入vptr的缘故)。反之,如果X原本就是多态类,则sizeof(Y)==sizeof(X)(因为这种情况下,Y中其实已经有了从X继承而来的vtbl及vptr,编译器所要做的只是将新增的虚函数纳入到vtbl中去)。定义 template struct is_polymorphic_imp1 //当T为类时使用这个版本 { typedef typename remove_cv::type ncvT; struct d1 : public ncvT //ncvT是将T的const volatile修饰符去掉后的型别,因为public后不能跟这样的 { //修饰符 d1(); //该类里没有虚函数 ~d1()throw(); char padding[256]; }; //d1中没有虚函数 struct d2 : public ncvT //在d2中加入一个虚函数 { d2(); virtual ~d2()throw(); //加入一个虚函数,如果ncvT为非多态则会导致vptr的加入从而多占用4字节 char padding[256]; }; static const bool value = (sizeof(d2) == sizeof(d1)); //如果T为多态类则valu为true }; template struct is_polymorphic_imp2 //当T并非类时采用这个版本 {static const bool value = false;}; //既然T不是类,那么就不存在多态,所以总是false template struct is_polymorphic_selector //这个selector根据is_class的真假来选择判断的方式 { template struct rebind //如果is_class为false则由is_polymorphic_imp2<>来判断 { //这将导致结果总是false typedef is_polymorphic_imp2 type; //使用_imp2 }; }; template <> 7 struct is_polymorphic_selector //当is_class为true时使用该特化版本 { template struct rebind //如果is_class为true,则由is_polymorphic_imp1<>来作判断 { typedef is_polymorphic_imp1 type; //使用_imp1 }; }; template struct is_polymorphic_imp // is_polymorphic<>完全由它实现 { 6 typedef is_polymorphic_selector< ::boost::is_class::value> selector; //选择selector 8 typedef typename selector::template rebind binder; // 9 typedef typename binder::type imp_type; static const bool value = imp_type::value; }; 注解 6处,如果T为类,则is_class::value为true,则那一行实际上就是: typedef is_polymorphic_selector selector; 这将决议为is_polymorphic_selector<>的第二个重载版本7,其中的template rebind将判断的任务交给is_polymorphic_imp1<>,所以8行的binder其实就是is_polymorphic_selector::rebind。而9行的imp_type其实就是is_polymorphic_imp1,结果正如预期。如果T不是类,按照类似的推导过程,最终会推导至is_polymorphic_imp2::value,这正是false。 “嗨!这太烦琐了!”你抱怨道:“可以简化!”。我知道,你可能会想到使用boost::ct_if(ct_if是?:三元操作符的编译期版本,像这样使用typedef ct_if::value result,则当CompileTimeBool为true时result为TypeIfTrue,否则result为TypeIfFalse。ct_if<>的实现很简单,模板偏特化而已)。于是你这样写: typedef typename boost::ct_if< boost::is_class::value, is_polymorphic_imp1, //is_class::value为true时的型别 is_polymorphic_imp2, // is_class::value为false时的型别 >::type imp_type; static const bool value = imp_type::value; 这在我的VC7.0环境下的确编译通过并正常工作,但是有一个小问题:假如T不是class,比如,T是一个int,则编译器的型别推导将is_polymorphic_imp1赋给ct_if<>的第二个模板参数,在这个过程中编译器会不会具现化is_polymorphic_imp1(或者,换句话说,编译器会不会去查看它的定义),如果具现化了,那么其内部的struct d1 : public ncvT会不会也跟着具现化为struct d1:public int,如果是这样,那么将会有编译期错误,因为C++标准不允许有public int这样的东西出现。事实上我的编译器没有报错,即是说它并没有去查看is_polymorphic_imp1的定义。但我不知道C++标准关于这点怎么说。然而Boost库所用的方法是标准所保证的。型别属性traits还有:alignment_of<>, is_const<>, is_volatile<>, is_pod<>, has_trivial_constructor<>等。 4. 型别间关系 is_base_and_derived<>( boost/type_traits/ is_base_and_derived.hpp) template struct bd_helper { template static type_traits::yes_type check(D const volatile *, T); //两个重载函数 static type_traits::no_type check(B const volatile *, int); }; template struct is_base_and_derived_impl2 { struct Host { operator B const volatile *() const; //该转换操作符当对象为const对象时才起作用 operator D const volatile *(); }; 10 static const bool value =sizeof(bd_helper::check(Host(), 0)) == sizeof(type_traits::yes_type); }; 以上就是is_base_and_derived<>的底层机制。下面我就为你讲解它所仰赖的机制,假设有这样的类继承体系: struct B {}; struct B1 : B {}; struct B2 : B {}; struct D : private B1, private B2 {}; //将D*转换为B1*会导致访问违规,私有基类部分无法访问首先是一些术语: //但是后面解释了这为什么不会发生 SC - Standard Conversion UDC - User-Defined Conversion 一个user-defined转换序列由一个SC后跟一个UDC后再跟一个SC组成。其中头尾两个SC都可以为到自身的转换(如:D->D), 10处将一个缺省构造的Host()交给bd_helper::check函数。对于static no_type check(B const volatile *, int),我们有如下可行的隐式转换序列: C -> C const (SC - Qualification Adjustment) -> B const volatile* (UDC) //C表示Host() C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* -> B const volatile* (SC - Conversion) 对于static yes_type check(D const volatile *, T),我们有如下转换序列: C -> D const volatile* (UDC) C++标准说,在重载决议中选择最佳匹配函数时,只考虑标准转换(SC)序列,而这个序列直到遇到一个UDC为止,对于第一个函数,将C->C const与C->C比较,显然选择后者。因为后者是前者的一个真子集。因此,去掉第一个转换序列我们得到: C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* -> B const volatile* (SC - Conversion) C -> D const volatile* (UDC) 这里采用选择最短序列的原则,选择后者,这表明编译器甚至根本不需要去考虑向B转换的多重路径,或者访问限制,所以转换二义性和访问违规也就不会发生。结论是如果D继承自B,则选择yes_type check()。 如果D不是继承自B,则对于static no_type check(B const volatile *, int)编译器的给出的转换为: C -> C const -> B const volatile*(UDC) 对于static yes_type check(D const volatile *, T)编译器给出: C -> D const volatile* (UDC) 这两个都不错(都需要一个UDC),然而由于static no_type check(B const volatile *, int)为非模板函数,所以被编译器选用。结论是如果D并非继承自B,则选择no_type check()。另外,在我的VC7.0环境下,如果将Host的operator B const volatile *() const的const拿掉,则结果将总是false。可惜这样的理解并不属于我,它们来自Boost源代码中的注释。 is_convertible<>(boost/type_traits/is_convertible.hpp) 定义 template< typename From > struct does_conversion_exist { template< typename To > struct result_ { static no_type _m_check(...); //当不存在从From到To的任何转型时调用它 static yes_type _m_check(To); //只要转型存在就调用它 static From _m_from; //这只是个声明,所以并不占用空间,且没有开销。 enum { value = sizeof( _m_check(_m_from) ) == sizeof(yes_type) }; }; }; template<> struct does_conversion_exist{ //这是个为void准备的特化版本,因为不能声明 template< typename To > struct result_{ //void _m_from enum { value = ::boost::is_void::value }; //只有void可以向void“转换” }; }; //is_convertible<>完全使用does_conversion_exist<>作底层机制,所以略去。注解 does_conversion_exist<>也使用了与is_class_impl<>一样的技术。所以注解从略。该技术最初由Andrei Alexandrescu发明,请参见Modern Design C++(<>--侯捷、於春景译)。型别间关系traits还有:is_same<>,它只是简单的模板偏特化。 5. Transformations Between Types(型别间转换) 6. Synthesizing Types(型别合成) 7. Function Traits(函数traits)的机制较为单纯,请参见Boost提供的文档或头文件。 Traits是泛型世界中的精灵:小巧,精致。Traits也是泛型编程中最精微的东西,它们往往仰赖于一些编译期决议的规则,C++标准,和神奇的模板偏特化。这也导致了它们在不同的平台上可能有不同表现,更常见的是,在某些平台上根本无法工作。然而,由于它们的依据是C++标准,而编译器会越来越符合标准,所以这些问题只是暂时的。Traits也是构建泛型世界的基本组件之一,它们往往能使设计变得优雅,精致,甚至完美。