woaidongmao

文章均收录自他人博客,但不喜标题前加-[转贴],因其丑陋,见谅!~
随笔 - 1469, 文章 - 0, 评论 - 661, 引用 - 0
数据加载中……

Trait和Template Mataprogram的奥秘

C++是一门复杂的语言,之所以复杂,就是因为被很多的大牛们发掘出了它的很多极其怪异的用法,或者也可以说是很高明的技巧,这些技巧,我们普通人难以掌握,也很少有非使用不可的时候,但是对于那些大牛们来说,却是必不可少的利器。不信的话,翻翻Boost的源码,这样复杂的技巧比比皆是。

这些技巧,有的我以前只是听说,比如Mataprogram;有的我曾经在使用库的时候碰到过,但是怎么也想不通为什么需要这么个东西,比如Trait。直到最近几天,读《C++ Template》的时候,才突然豁然开朗。这里写出来和大家分享。

先来说说Trait,这是一个在C++ Template编程中经常用到的一个设计机制,在使用某些库的时候我也经常碰到。比如说STL库中的basic_string,其定义如下:
template <
  
class CharType,
  
class Traits=char_traits<CharType>,
  
class Allocator=allocator<CharType> 
>
class basic_string


其中就有一个模板参数为Traits,而它的默认值为char_traits<CharType>,这里的char_traits<>就是一个trait类,它可以提供关于CharType的特征信息。我们常用的string类的定义如下:
typedef basic_string<char> string

如果我们把它的默认模板参数带入,就可以看到string的形式是这样的:
basic_string< char, char_traits<char>, allocator<char> >


到这里,我就迷糊了,我在想,为什么char_trait<>就能够取得char的类型信息?为什么basic_string<>就不行?难道说加上trait这几个字,模板类就有了三头六臂不成?

另外还有一个例子就是ATL 3.0中的窗口类,这是我很早以前翻译的一篇文章,其中也使用到了Trait,在定义窗口样式的时候,其代码如下:
class CMyWindow: public CWindowImpl<
   CMyWindow,
   CWindow,
   CWinTraits
<WS_OVERLAPPEDWINDOW|WS_VISIBLE,0> 
>
{};

当时我就想了,为什么不直接把“WS_OVERLAPPEDWINDOW|WS_VISIBLE,0”当成模板参数传递给CWindowImpl<>算了,还非要CWinTraits<>来掺和一把?

直到现在,我终于知道,原来一直错的就是我。我不该把char_traits<>看成是一个模板类,不该认为传给它一个char它就可以读出char的特征信息,传给它一个int它就能读出int的特征信息。它当然不可能具备这么高级的功能,更不可能加上traits几个字就一下子挣脱了C++语言的束缚。

那么不把它看成一个模板类,应该怎么看呢?应该把char_traits<char>看成一个整体,说专业点,那叫模板特化,说通俗点,就是原来这里面的特征信息都是编写它的人自己定义的,如果你要让basic_string能够处理int,double之类的信息,你还得自己写一个char_traits<int>和一个char_traits<double>。CWinTraits<...>也同样是这个道理。

为了说得更清楚点,我这里举个小例子。什么例子呢?就写个计算平均值的模板函数吧,如下:
template <typename T>
T average(T
const* begin, T const* end)
{
    T total
= T();
   
int count = 0;
   
while (begin != end){
        total
+= * begin;
       
++begin;
       
++count;
    }
   
return total/count;
}

下面是使用这个函数的代码,如果我们计算的类型是int,结果是正确的,如下:
int main(){
   
int numbers[] = {1,2,3,4,5};
    std::cout
<< average(&numbers[0],&numbers[5]) << std::endl;
}

该程序运行的结果是3,非常正确,将数据类型换成float,double也没有问题。但是,如果是char类型,就不一定了。代码如下:
int main(){
   
char characters[] = "traits";
    std::cout
<< static_cast<int>(average(&characters[0],&characters[6])) << std::endl;
}


运行结果为 -17,不信大家可以自己运行试一下。为什么是个负数呢?

原因是因为char类型能表示的范围只有-127到+128,几个字母一加,就溢出了。为了得到正确的结果,我们希望能有一种机制,来指定运算的时候用什么作为返回类型,这时候,traits就可以闪亮登场了。前面已经说过,要把trait<...>看成一个整体,所以应该为每一个数据类型都定义一个trait。在这个例子中,我们主要是为了对每一个运算的类型指定合适的返回类型,任务比较简单,所以,代码可以这样写:

template <typename T>
class TypeTraits;

template
<>
class TypeTraits<char>{
public:
    typedef
int ReturnType;
}

template
<>
class TypeTraits<short>{
public:
    typedef
int ReturnType;
}

template
<>
class TypeTraits<int>{
public:
    typedef
int ReturnType;
}

template
<>
class TypeTraits<float>{
public:
    typedef
double ReturnType;
}

函数可以改成这样:
template <typename T,typename Traits>
typename Traits::ReturnType average(T
const* begin, T const* end)
{
    typedef typename Traits::ReturnType ReturnType;
    ReturnType total
= ReturnType();
   
int count = 0;
   
while (begin != end){
        total
+= * begin;
       
++begin;
       
++count;
    }
   
return total/count;
}

使用该函数的代码是这样:
int main(){
   
int numbers[] = {1,2,3,4,5};
    std::cout
<< average<int,TypeTraits<int> >(&numbers[0],&numbers[5]) << std::endl;
   
char characters[] = "traits";
    std::cout
<< average<char,TypeTraits<char> >(&characters[0],&characters[6]) << std::endl;
}

这时候,一切都正常了。只可惜模板函数不支持默认模板参数,要不然,这里的代码可以更简洁。

再来说说Template Mataprogram,中文叫模板元编程。这个东西,我很早就听说过,如雷灌耳。听说它主要有这样几个特点:
1、它编的程序不是运行的时候执行的,而是在编译的时候由编译器执行的;
2、它能够牵着编译器的鼻子走,靠的完全是符合标准的模板语法,不需要使用编译器的任何API;
3、它居然是图灵完备的,也就是说它什么事都能干。

牛吧?C++提供了一个模板机制,这些大牛们居然可以用模板把编译器耍得团团转,居然能在程序还没运行的时候就什么都能干。反正我是崇拜得五体投地。直到最近看书,才找到了它的奥秘所在,当然了,只限于基本原理。

那么,这个基本原理是怎样的呢?其实就是靠的模板的实例化,和使用枚举值或静态常量。具体来说是这样:当编译器遇到enum的定义的时候,就会对该enum进行求值,这个求值是在编译期进行的,而如果该enum对应的表达式是一个模板类的成员,则会实例化该模板类,而实例化模板类的时候,又是递归进行的,这样,就可以在递归的过程中作我们想做的任何事(理论上可以做任何事,但是以我的水平,也就只能算算加减乘除)。看起来是不是不好理解?没关系,下面看一个例子,计算N的阶乘:
template <int N>
class Factorial
{
public:
   
enum { result = N * Factorial<N-1>::result };
};

这下该明白了吧,为了得到Factorial<N>::result的值,就会实例化Factorial<N>,然后又会实例化Factorial<N-1>,依次类推,一直递归下去。那么什么时候结束呢?所以还需要一个特化版本:
template<>
class Factorial<1>
{
public:
   
enum { result = 1 };
}

下面写几行代码测试一下,如下:
int main()
{
    std::cout
<< Factorial<10>::result << std::endl;
   
return 0;
}

OK,事情就这么简单。大家都知道,递归可以代替循环,就只是对内存的消耗大一些,所以递归的层次不能太多。解决了循环的问题,那么分支结构如何解决呢?

不用担心,看看下面这样的模板定义:
template <bool C, typename Ta, typename Tb>
class IfThenElse;

template
<typename Ta, typename Tb>
class IfThenElse<true, Ta, Tb>{
public:
    typedef Ta ResultT;
};

template
<typename Ta, typename Tb>
class IfThenElse<false, Ta, Tb>{
public:
    typedef Tb ResultT;
};

一个模板类加上两个局部特化版本就解决了问题,如果第一个模板参数是true,则选择Ta作为结果,否则就选择Tb作为结果。

虽然C++为我们提供了模板元编程的能力,虽然我现在知道了它的基本实现机制,但是我依然想不到究竟什么时候需要用到模板元编程。看来我还需要读更多的书更多的文章。同时,我觉得我们还是应该保持简单的事情简单化,继续写我的简单代码吧。

posted on 2008-08-31 21:23 肥仔 阅读(359) 评论(0)  编辑 收藏 引用 所属分类: C++ 模板


只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理