C++泛型idioms之一: trait

来源：互联网发布：淘宝1元秒杀软件编辑：程序博客网时间：2024/05/22 00:10

刚着手写这篇文章的时候,实在不知道该从何处下笔,关于泛型技术有太多的东西可写。

这里我不打算详细讲解关于泛型,关于template的语法细则,单单这一部分完全可以写一本书出来,而且也确实已经有很好的资源可以供我们参考----《C++ Templates - The Complete Guide》。

除了语法，还有什么？Template？STL？是的，对于C++来说，泛型程序设计本身就是基于模块的程序设计，并且已经广泛应用于STL当中。

然而泛型并不仅限于此。

在这个系列文章里，我想展示的是一些或许有些极端的、在实际编程中很少用到的泛型idioms（惯用技法）。然而正如侯捷先生所说：由来技术的推演，并不只是问一句“它有用吗”或“它现在有用吗”可以论断价值的。牛顿发表万有引力公式，并不知道三百年后人们用来计算轨道、登陆月球。个人的成长千万别被群体的惯性绊住脚步。我们曾经鄙夷的别人的“无谓”前卫，可能只因我们故步自封，陷自己于一成不变的行为模式；或因此我们只看到自家井口的天空。深度+广度，古典+前卫，理论+应用，实验室+工厂，才能构筑一个不断进步的世界。

做为泛型的惯用技法，最常用（在STL中随处可见），最简单的恐怕就要数trait了。好了，下面我们先引入trait的定义：

Traits class: A class used in place of template parameters. As a class, it aggregates useful types and constants; as a template, it provides an avenue for that "extra level of indirection" that solves all software problems.

有些抽象吧，下面我们通过代码来说明问题。

假设我们有一组数据存储在数组当中,并且我们有一个指向第一个元素的指针和指向最后一个元素的指针,现在我们要对数组中的所有元素求和,一般的方法就不写了,下面我们直接看它的泛型做法:

template <typename T> 
inline 
T accum (T const* beg, T const* end) 
{ 
T total = T();  // assume T() actually creates a zero value  
while (beg != end) { 
total += *beg; 
++beg; 
} 
 return total; 
} 

这里有一个小问题：如何为正确的类型生成一个0值，以便开始我们的求和计算。对于int和float等内建类型而言，T()都可以符合要求，对于其他的类型，我们稍后讲解。

下面是使用了上文模板的一段代码:

　　int num[]={1,2,3,4,5}; 
　　// print average value  
　　std::cout << "the average value of the integer values is " 
          << accum(&num[0], &num[5]) / 5 
          << '/n'; 
　　// create array of character values  
　　char name[] = "templates"; 
　　int length = sizeof(name)-1; 
　　// (try to) print average character value  
　　std::cout << "the average value of the characters in /"" 
          << name << "/" is " 
          << accum(&name[0], &name[length]) / length 
          << '/n'; 

程序的输出结果是:

the average value of the integer values is 3
the average value of the characters in "templates" is -5

等一下,这里有个问题不是吗?对于前面部分,程序还算运行正常,但是后半部分由于我们以char类型实例化模板,数组中数据的和超过了它的范围,产生了越界。显然这不是我们想要的结果。

问题已经知道了，但是我们要如何解决呢？一个比较好的办法是对accum()所调用的每个T类型都创建一个关联，所关联的类型就是用来存储累加和的类型。这些关联可以看作是类型T的一个特征，因此，我们也把这个存储累加和的类型称为T的trait。

template<typename T> 
class AccumulationTraits; 
template<> 
class AccumulationTraits<char> { 
  public: 
    typedef int AccT; 
}; 
template<> 
class AccumulationTraits<short> { 
  public: 
    typedef int AccT; 
}; 
template<> 
class AccumulationTraits<int> { 
  public: 
    typedef long AccT; 
}; 
template<> 
class AccumulationTraits<unsigned int> { 
  public: 
    typedef unsigned long AccT; 
}; 
template<> 
class AccumulationTraits<float> { 
  public: 
    typedef double AccT; 
}; 

上文中，AccumulationTraits被称为一个trait模板，因为它含有它的参数类型的一个trait。通过特化，我们为特定的类型指定其累加和类型。现在我们修改前面的模板代码如下：

　　template <typename T> 
　　inline 
　　typename AccumulationTraits<T>::AccT accum (T const* beg, 
                                            T const* end) 
　　{ 
    　　// return type is traits of the element type  
    　　typedef typename AccumulationTraits<T>::AccT AccT; 
    　　AccT total = AccT();  // assume T() actually creates a zero value  
    　　while (beg != end) { 
        　　total += *beg; 
        　　++beg; 
    　　} 
    　　return total; 
　　} 

于是，现在例子程序中的输出就完全符合我们的期望了。

对了，我们还留有一个问题不是吗？那就是T（）如何解决呢？方法跟上面的累加和trait类似，不过这里我们提供的是一个内联成员函数，来避开C++关于类的静态成员变量的某些限制。

template<typename T> 
class AccumulationTraits; 
template<> 
class AccumulationTraits<char> { 
  public: 
    typedef int AccT; 
    static AccT zero() { 
        return 0; 
    } 
}; 
template<> 
class AccumulationTraits<short> { 
  public: 
    typedef int AccT; 
    static AccT zero() { 
        return 0; 
    } 
}; 
template<> 
class AccumulationTraits<int> { 
  public: 
    typedef long AccT; 
    static AccT zero() { 
        return 0; 
    } 
}; 
template<> 
class AccumulationTraits<unsigned int> { 
  public: 
    typedef unsigned long AccT; 
    static AccT zero() { 
        return 0; 
    } 
}; 
template<> 
class AccumulationTraits<float> { 
  public: 
    typedef double AccT; 
    static AccT zero() { 
        return 0; 
    } 
}; 

之后，在accum()中把T()替换为AccT total = AccumulationTraits<T>::zero(); ,到这里大功告成。

在上面的例子中，我们把accum跟AccumulationTraits绑定在一起了，这样当我们改变主意不打算使用AccumulationTraits的时候多少有点不方便。不过没关系，我们可以通过缺省模板参数来搞定它。由于函数模板不支持缺省模板实参，那么，我们只好改用类模板了。

    template <typename T, 
              typename AT = AccumulationTraits<T> > 
    class Accum { 
      public: 
        static typename AT::AccT accum (T const* beg, T const* end) { 
            typename AT::AccT total = AT::zero(); 
            while (beg != end) { 
                total += *beg; 
                ++beg; 
            } 
            return total; 
        } 
    }; 

最后，我们可以引入一个辅助函数，来简化上面基于类的接口：

　　template <typename Traits, typename T> 
　　inline 
　　typename Traits::AccT accum (T const* beg, T const* end) 
　　{ 
    　　return Accum<T, Traits>::accum(beg, end); 
　　} 

在STL中，trait又被应用在哪里呢？没错，就是迭代器。最常用到的迭代器类型有五种，分别是：value type, difference type, pointer, reference, iterator catagoly。traits这一“特性萃取机”会忠实地将它们原汗原味地榨取出来：

　　template <class I>
　　struct iterator_traits{
　　　　typedef typename I::iterator_category iterator_category;
　　　　typedef typename I::value_type value_type;
　　　　typedef typename I::difference_type difference_type;
　　　　typedef typename I::pointer pointer;
　　　　typedef typename I::reference reference;
　　};

然而，多了这一个间接层，会带来什么好处呢？好处是我们可以拥有特化版本，比如针对原生指针的特化，等等。从而我们使用迭代器时便有了统一的接口。

最后我们来总结一下trait：trait表述了模板参数的一些自然的额外属性（当然它可以不需要通过模板参数传递），它通常都具有很自然的缺省值，可以紧密依赖于一个或多个主参数，并通过trait模板来实现。

关于trait技术我就总结到这里了，如果你意犹未尽的话，可以继续阅读《C++ Templates》，其中包含了更错综复杂的演变过程。