[笔记]读书笔记 C++设计新思维《二》技术（Techniques）（二）-阿里云开发者社区

2.3 局部类（Local Classes)

这是一个有趣而少有人知道的C++特性。你可以在函数中定义class，像下面这样:

void Fun ( ){
  class Local{
    .. . member variables ...
    ... member function definitions ...
  };
  .. code using Local ...
}

不过还是有些限制：

local class不能定义static成员变量（不能定义静态成员变量）
也不能访问non-static局部变量。（非静态局部变量）

local classes令人感兴趣的是，可以在template函数中被使用。定义于template函数内的 local classes可以运用函数的template参数。以下所列代码中有一个MakeAdapter template function，可以将某个接口转接为另一个接口.MakeAdaptery在其local class的协助下实作出一个接口。这个localclass内有泛化型别的成员。

class Interface
{
  public:
  virtual void Fun ( ,=0;
};
template <class T, class P>
Interface* MakeAdapter (const T& obj, const P& arg)(
    class Local : public Interface{
      public:
        Local (const T& obj, const P& arg)
        : obj_(obj) , arg_ ( arg){ }virtual void Fun ( )
        {
          obj_.call (arg_) ;
        )
      private :
        T obj_;P arg_;
    };
  return new Local ( obj, arg ) ;
}

事实证明，任何运用local classes 的手法，都可以改用“函数外的template classes”来完成。换言之，并非一定得local classes不可。

不过 local classes可以简化实作并提高符号的地域性。Local classes 倒是有个独特性质:它们是“最后一版”(也即 Java口中的final）。外界不能继承一个隐藏于函数内的 class。如果没有local classes，为了实现Java final，你必须在编译单元（译注:也就是个别文件）中加上一个无具名的命名空间(namespace）。

我将在第11章运用local classes 产生所谓的“弹簧垫”函数(trampoline functions)。

2.4 常整数映射为型别( Mapping Integral Constants to Types）

下面是最初由Alexandrescu ( 2000b）提出的一个简单template，对许多泛型编程手法很有帮助:

template <int v>
struct Int2Type
{
  enum {value = v } ;
} ;

Int2Type会根据引数所得的不同数值来产生不同型别。这是因为“不同的template具现体”本身便是“不同的型别”。因此Int2Type<0>不同于Int2Type<1>，以此类推。用来产生型别的那个数值是一个枚举值( enumerator)。

当你想把常数视同型别时，便可采用上述的Int2Type。这么一来便可根据编译期计算出来的结果选用不同的函数。实际上你可以运用一个常数达到静态分派（static dispatching) 功能。

一般而言，符合下列两个条件便可使用Int2Type:

有必要根据某个编译期常数调用一个或数个不同的函数。
有必要在编译期实施“分派”( dispatch）。

如果打算在执行期进行分派（dispatch)，可使用if-else或switch语句。大部分时候其执行期成本都微不足道。然而你还是无法常常那么做，因为 if-else语句要求每一个分支都得编译成功，即使该条件测试在编译期才知道。困惑了吗?读下去!

假想你设计出…个泛形容器Niftycontainer，它将元素型别参数化:

template <class T> 
class NiftyContainer
{
  ...
}

现在假设Niftycontainer内含指针，指向型别为T的对象。为了复制Niftycontainer里的某个对象，你想调用其 copy构造函数（针对non-polymorphic型别）或虚函数clone ()（针对polymorphic型别）。你以-一个boolean template参数取得使用者所提供的信息：

tempiate <typename T, bool isPolymorphic>
class NiftyContainer
{
  void DoSomething ()
  {
    T* pSomeObj = .. .;
    if(1sPo1 ymorphic){
      *pNewObj = psomeObj->Clone () ;
      ... 
      polymorphic algorithm ...(多态算法)
    }
    else{
      *pNewObj = new T ( *pSome0bj ) ;//译注:copy构造函数
      ... non-polymorphic algorithm ... （非多态算法)
    }
  }
};

问题是，编译器不会让你侥幸成功。如果多态算法使用pobj->Clone )，那么面对任何一个未曾定义成员函数clone ()之型别，NiftyContainer: : DoSomething ()都无法编译成功。虽然编译期间很容易知道哪一条分支会被执行起来，但这和编译器无关，因为即使优化工具可以评估出哪一条分支不会被执行，编译器还是会勤劳地编译每个分支。如果你试着调用Niftycontainer<int,false>的 DoSomething )，编译器会停在p0bj->clone ( )处并说“嗨，不行哨”。

上述的non-polymorphic部分也有可能编译失败。如果T是个 polymorphic型别，而上述的non-polymorphic程序分支想做newT( *pObj)动作，这样也有可能编译失败。举个实例，如果T借着“把 copy构造函数置于private区域以产生隐藏效果”,就像一个有良好设计的polymorphicclass那样，那么便有可能出现上述的失败情况。

如果编译器不去理会那个不可能被执行的代码就好了，然而目前情况下是不可能的。甚么才是令人满意的解决方案呢?

事实证明有很多解法，而Int2Type提供了一个特别明确的方案。它可以把isPolymorphic这个型别的 true和 false 转换成两个可资区别的不同型别，然后在程序中便可以运用Int2Type进行函数重载。瞧，可不是吗!

template <typename T, bool 1sPo1ymorphicclass Ni ftyContainer
{
private:
  void Dosomething ( T* pobj, Int2Type<true>)
  {
    T*pNewObj = pObj->Clone ( );... polymorphic algorithm .
  }
  void Dosomething (T*pObj, int2Type<false>){
    T* pNewobj = new T ( *pobj ) ;... nonpo1 ymorphic algorithm .
  }
public:
  void Dosomething ( r* pObj){
    Dosomething (pobj, Int2Type<isPolymorphic> () );
  }
};

Int2Type是一个用来“将数值转换为型别”的方便手法。有了它，你便可以将该型别的一个暂时对象传给一个重载函数(overloaded function)，后者实现必要的算法。

(译注：这种手法在STL中亦有大量实现，唯形式略有不同;详见STL源码，或《STL源码剖析》by 侯捷

这个小技巧之所以有效，最主要的原因是，编译器并不会去编译一个未被用到的template函数，只会对它做文法检查。至于此技巧之所以有用，则是因为在 template 代码中大部分情形下你需要在编译期做流程分派(dispatch）动作。

你会在Loki的数个地方看到Int2Type的运用，尤其是本书第11章:Muttimethods。

在那儿，template class是个 双分派（double-dispatch）引擎，运用bool template参数决定是否要支持对称性分派(symmetric dispatch） 。

2.5 类别对类别的映射

就如2.2节所说，并不存在template函数的偏特化。然而偶尔我们需要模拟出类似机制。

试想下面的程序:

template <class T, class U>
T* Create (const U& arg)
{
  return new T ( arg ) ;
}

create( )会将其参数传给构造函数，用以产生一个新对象。

现在假设你的程序有个规则: widget对象是你碰触不到的老旧代码，它需要两个引数才能构造出对象来，第二引数固定为-1。widget派生类则没有这个问题。

现在你该如何特化Create ()，使它能够独特地处理widget呢?一个明显的方案是另写出一个CreateWidget()来专门处理。但这么一来你就没有一个统一的接口用来生成widgets和其派生对象。这会使得create ()在任何泛型程序中不再有用。

由于你无法偏特化一个函数，因此无法写出下面这样的代码:

//llegal code — don 't try this at home
template <class U>
Widget* Create<Widget, U> (const U& arg)
{
return new widget (arg,一1);
}

由于函数缺乏偏特化机制，因此（再一次地）你只有一样工具可用:

多载化（重载）机制。

我们可以传入一个型别为T的暂时对象，并以此进行重载:

template <class T , class U>
T* Create (const U&arg, T /*dummy */)
{
  return new T ( arg) ;
}
template <class U>
Widget* Create (const U& arg,Widget /*dummy*/)
{
  return new Widget (arg,-1) ;
)

这种解法会轻意构造未被使用的复杂对象，造成额外开销。我们需要个轻量级机制来传递“型别T的信息”到Create()中。这正是Type2Type扮演的角色，它是一个型别代表物，一个可以让你传给重载函数的轻量级ID。Type2Type定义如下:

template <typename T>
struct Type2Type
{
  typedef T OriginalType;
};

它没有任何数值，但其不同型别却足以区分各个 Type2Type实体，这正是我们所要的。现在你可以这么写:

// An implementation of Create relying on overloadinglland Type2Type
template <class T, class U>
T* Create (const U&arg, Type2Type<T>)
{
  return new T (arg) ;
}
template <class U>
Widget* Create(const U& arg, Type2Type<Widget>)
{
  return new widget (arg,-1）;
}
// Use Create ( )
String* pStr = Create("Hello",Type2Type<String> ());
Widget* pW - Create(100,Type2Type<Widget>());

Create()的第二参数只是用来选择适当的重载函数,现在你可以令各种 Type2Type实体对应于你的程序中的各种型别，并根据不同的 Type2Type实体来特化Create ( )。

2.6 类别的选择

有时候，泛型程序需要根据一个boolean变量来选择某个型别或另一型别。

在2.4节讨论的NiftyContainer例子中，你也许会以一个std::vector作为后端存储结构。很显然，面对 Polymorphic（(多态〉型别，你不能存储其对象实体，必须存储其指针。但如果面对的是non-polymorphic（非多态）型别，你可以存储其实体，因为这样比较有效率，在你的class template 中：

template <typename T, bool isPolymorphic>
class Niftycontainer
{
  ...
}

你需要存放一个vector<T*>（如果 isPolymorphic 为true）或vector（如果isPolymorphic为 false）。根本而言，你需要根据isPolymorphic来决定将valueType定义为T*或T。你可以使用traits class template ( Alexandrescu 2000a）如下:

template <typename T, bool isPo1ymorphic>
struct NiftyContainerValueTraits
{
  typedef T* ValueType;
};
template <typename T>
struct NiftyContainerValueTraits<T, false>
{
  typedef T ValueType;
};
template <typename T, bool isPolymorphic>
class NiftyContainer
{
  ...
  typedef NiftyContainerValueTraits<T, isPolymorphic> Traits;
  typedef typename Traits::ValueType  valueType;
};

这样的做法其实笨拙难用，此外它也无法扩充:针对不同的型别的选择，你都必须定义出专属的 traits class template。

Loki提供的 Select Class template可使型别的选择立时可用。它采用偏特化机制(Partial Template Specialization) :

template <bool flag, typename T, typename u>struct select
{
typedef T Result;
) ;
template <typename r, typename u>struct select<false, T ,U>
{
typedef U Result;
} ;

2.7 便器期间侦测可转换性和继承性

实作 template functions 和 template classes时我常常发现一个问题:面对两个陌生的型别T和U,如何知道U是否继承自T呢? 在编译期间发掘这样的关系，实在是实作泛型程序库的一个优化关键。在泛型函数中，如果你确知某个class实作有某个接口，你便可以采用某个最佳算法。在编译期发现这样的关系，意味着不必使用dynamic_cast——它会耗损执行期效率。

发掘继承关系，靠的是一个用来侦测可转换性(convertibility)的更一般化机制。这里我们面临更一般化的问题:

如何测知任意型别T是否可以自动转换为型别U?

有个方案可以解决问题，并且只需依赖sizeof。

sizeof有着惊人的威力:你可以把sizeof用在任何表达式 (expression）身上，不论后者有多复杂。sizeof 会直接传回大小，不需拖到执行期才评估。这意味着sizeof 可以

感知重载(overloading)、
模板具现( template instantiation)、
转换规则(conversion rules)，

或任何可发生于C+表达式身上的机制。

事实上sizeof背后隐藏了一个“用以推导表达式型别”的完整设施。最终sizeof 会丢弃表达式并传回其大小¹。

“侦测转换能力”的想法是:合并运用sizeof 和重载函数。我们提供两个重载函数:其中一个接受U(U型别代表目前讨论中的转换目标），另一个接受“任何其他型别”。我们以型别T的暂时对象来调用这些重载函数，而“T是否可转换为U”正是我们想知道的。如果接受U的那个函数被调用，我们就知道T可转换为U;否则T便无法转换为U。

为了知道哪一个函数被调用，我们对这两个重载函数安排大小不同的返回型别，并以 sizeof来区分其大小。型别本身无关紧要，重要的是其大小必须不同。

让我们先建立两个不同大小的型别。很显然char和 long double的大小不同，不过C++标准规格书并未保证此事，所以我想到一个极其简单的做法:

typedef char Small;
class Big { char dummy [2]; } ;

2.8 type_info的一个外覆类

std::type_info class

标准C++提供了一个std::type_info class，使你能够于执行期间查询对象型别。

外覆类

2.9 NullType和EmptyType

Loki 定义了两个非常简单的型别: NullType和 EmptyType。你可以拿它们当做型别计算时的某种边界标记。

NullType

NullType是一个只有声明而无定义的class:

class NullType;// no definition

你不能生成一个NullType对象，它只被用来表示“我不是个令人感兴趣的型别”。2.10节把NullType用在有语法需求却无语义概念的地方(例如“int 指的是什么型别”)。第3章的 typelist以NullType标记typelist的末端，并用以传回“找不到型别”这一消息。

EmptyType

第二个辅助型别是EmptyType。和你想的一样，EmptyType定义如下:

struct EmptyType i } ;

这是一个可被继承的合法型别，而且.你可以传递EmptyType对象。你可以把这个轻量级型别视为template的缺省（可不理会的）参数型别。第3章的 typelist就是这样用它的。

2.10 Type Traits

前言

Traits是一种“可于编译期根据型别作判断”的泛型技术，很像你在执行期根据数值进行判断一样（Alexandrescu 2000a)。众所皆知，加上一个间接层便可解决很多工程问题，trait让你得以在“型别确立当时”以外的其他地点做出与型别相关的判断。这会让最终的代码变得比较干净，更具可读性，而且更好维护。

通常，当你的泛型程序需要时，你会写出自己的trait templates 和 trait classes。然而某些traits可应用于任何型别，它们可以帮助泛型程序员根据型别特性修改出适当的泛型代码。

template <typename InIt, typename OutIt >
OutIt Copy (InIt first, InIt last,OutIt result)
{
  for (; first != last ; ++first, ++result )
  *result * first ;
}

std::copy函数

2.10.1 实作出PointerTraits

2.10.2 侦测基本类别

2.10.3 优化的参数类别

2.10.4 卸除饰词

2.10.5运用TypeTraits

2.10.6 包装

2.11 摘要

总结一

模板几个作用：

静态检测 2.1节
静态重载，选择合适的分支 2.4节

总结二

函数虽然无法使用模板偏特化，但是可以使用重载 2.4节

目前正有一份提案，准备为C++语言加入typeof操作符，它会传回一个表达式的型别。有了这个typeof操作符，泛型程序将会更好写，也更易被了解。Gnu C++己实作出typeof作为语言扩充功能。很显然typeof和sizeof拥有共同的后端实作，因为 sizeof也需要判断型别

[笔记]读书笔记 C++设计新思维《二》技术（Techniques）（二）

2.3 局部类（Local Classes)

2.4 常整数映射为型别( Mapping Integral Constants to Types）

2.5 类别对类别的映射

2.6 类别的选择

2.7 便器期间侦测可转换性和继承性

2.8 type_info的一个外覆类

std::type_info class

外覆类

2.9 NullType和EmptyType

NullType

EmptyType

2.10 Type Traits

前言

std::copy函数

2.10.1 实作出PointerTraits

2.10.2 侦测基本类别

2.10.3 优化的参数类别

2.10.4 卸除饰词

2.10.5运用TypeTraits

2.10.6 包装

2.11 摘要

总结一

总结二

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

[笔记]读书笔记 C++设计新思维《二》技术（Techniques）（二）

2.3 局部类（Local Classes)

2.4 常整数 映射为 型别( Mapping Integral Constants to Types）

2.5 类别对类别的映射

2.6 类别的选择

2.7 便器期间侦测可转换性和继承性

2.8 type_info的一个外覆类

std::type_info class

外覆类

2.9 NullType和EmptyType

NullType

EmptyType

2.10 Type Traits

前言

std::copy函数

2.10.1 实作出PointerTraits

2.10.2 侦测基本类别

2.10.3 优化的参数类别

2.10.4 卸除饰词

2.10.5运用TypeTraits

2.10.6 包装

2.11 摘要

总结一

总结二

热门文章

最新文章

相关课程

相关电子书

相关实验场景

2.4 常整数映射为型别( Mapping Integral Constants to Types）