#include <cstdio>

typedef int (*fun)(int);
int f1(int i) {return 0;}
int f2(int i) {fun f[2]={f1,f2}; return i+f[!!i](i-1);}
int main()
{
     printf("%d\n",f2(1000));
}

#include <cstdio>

typedef void (*fun)(int i,int n); 
void f1(int i,int n);
void f2(int i,int n);
void f3(int i,int n);

void f1(int i,int n)
{
     fun f[2]={f1,f2};

     printf("%d\n",i);
     f[i+1==n](i+1,n);
}
void f2(int i,int n)
{
     fun f[2]={f2,f3};
     printf("%d\n",i);
     f[i==1](i-1,n);
}
void f3(int i,int n) {}

int main()
{
     f1(1,100);
}

#include <cstdio>

void f(int i,int n)
{
     printf("%d\n",i),(i<n)&&(f(i+1,n),printf("%d\n",i));
}

int main()
{
     f(1,100);
}

从系统结构上来讲， C/C++ 支持 3 种内存管理方式，基于栈的自动管理，基于堆的动态管理，和基于全局区的静态管理。由于 RAII 的理念，对于 C++ 来说，内存管理和其他资源管理本质上没有区别。因此对于资源而言，也就自然的拥有这样 3 种管理方式。

首先简要的介绍一下 RAII 。 RAII 的全称是 Resource Acquisition Is initialization 。这个思想的基本手法是对于一种想要使用的资源，为其书写一个 guard 类，在该类的构造函数里进行资源的请求，在析构函数里进行资源的释放。例如假设我们想管理一个互斥锁，可能的方式是：

struct  lock_guard
{
        lock_guard() { lock ();}
         ~ lock_guard() {unlock();}
} ;

     此后，对这个对象使用什么内存管理方式，也就等价于对这个互斥锁使用什么内存管理方式。

         借助于 RAII ，以后我们可以只讨论内存资源的管理方式，其它资源的管理方式可以使用 RAII 来同样的实现。现在我们已经很自然的获得了资源管理的 3 种方式：基于堆的动态方式、基于栈的自动方式和全局。值得一提的是，这 3 种方式中比较不容易出错的后两种实际上可以解决大部分的资源管理需求。因为绝大部分资源，都属于获取 - 使用 - 释放型的，例如很多同步对象，文件锁， WinGDI 里的许多 GDI 对象。我们缺乏管理的，只有那些一次获得，多个环境拥有，并且只能有一次释放的少数资源。

         回到内存模型来看，有一点让我们无法将内存与其它资源等同（反过来，把其它资源和内存等同却是可以的），那就是循环引用。 A 内存可以持有指向 B 内存的引用， B 内存也可以反过来持有 A 内存的引用。循环引用导致内存管理不可以用“是否有指向该内存的引用”来区分一块内存是否可以回收。从而丧失了一个绝佳的管理手段。但是在没有循环引用的场合下，我们还是有非常简洁高效的管理方法的。那就是引用计数。

         引用计数是在没有循环引用场合下进行内存管理的绝佳手段，它具有轻量、高效、即时、可控的优点。而且在 C++ 里，引用计数已经非常成熟，只需要使用 boost.shared_ptr 或者其它非官方的引用计数指针库就可以了，而且据悉 C++09 很可能把 boost.shared_ptr 纳入标准库。引用计数的原则是，如果一个对象没有别的指针或引用来指向它，那么这个对象就是可以释放的。具体的手法有大把大把的资料可以查阅，这里就不详细说明了。引用计数通常可以处理哪些场合的资源管理问题呢？首先，对于单方向的资源管理，也就是多个 A 的实体拥有 1 个 B ，然而 B 并不会反过来依赖于 A （例如多个对象共享一个日志），引用计数是非常合适的。其次，对于拥有 - 反作用的场合，也就是 1 个或多个 A 的实体拥有 1 个或多个 B ，而 B 也拥有这些 A 的实体的引用，但是 B 的生存期仍然决定于 A 的生存期（例如父窗口拥有若干子窗口，子窗口也具有 parent 指针指向父窗口，但是子窗口的生存期决定于父窗口的生存期），这个时候 A 可以对 B 使用引用计数指针，而 B 可以对 A 使用原生的普通指针，同样的可以很好的解决问题。

         现在所剩下的，就只有生存期的循环依赖了。如果 AB 互相持有对方的引用，而且 AB 互相的存在都依赖于对方，这样引用计数就无法解决了。但是如果仔细想一下就会发现，这种情况在 C++ 里几乎不可能存在。生存期循环依赖只有 2 种后果，要么 A 和 B 的析构函数里互相析构（当然就挂了），要么互相都不析构（当然就泄露了）。而这两种都是在正常编程中不会出现的情况。所以如果即使仅仅使用引用计数，我们也可以解决几乎所有的资源管理问题。

现在还剩下那么一丁点极少出现的不能处理的情况，我们可以使用更加复杂的 gc 来实现。可惜的是，实现一个 gc 所要耗费的精力实在太大，而且几乎不可避免的要成为侵入式的库。所以有点得不偿失。而且 gc 通常会产生更多的毛病：

1．               你无法却知对象析构的具体时间，从而无法真正知道影响程序性能的瓶颈在什么地方。

2．               gc 都倾向于大量的使用内存，直到内存不够的时候再进行清理，这样会导致程序的内存用量严重颠簸，并且产生大量的换页。

3．               过度的依赖于 gc 会使程序员大量的把可以由之前提到的各种方法来处理的资源交给 gc 来处理，无故的加重了 gc 的负担。

4．               gc 的管理方法和 C++ 的析构函数有可能产生语义上的冲突。

这就是为什么 C++ 标准对垃圾回收的态度如此恶劣的原因。

我们现在回过头来看 Java/C# 这样的内置 gc 的语言。这样的语言由于使用了 gc ，就不可避免的放弃了析构函数。为什么 gc 会和析构函数产生冲突呢？一个 gc 一般会希望在进行垃圾回收的时候，整个过程是一个原子的，但析构函数会破坏这一点，在释放内存的时候如果还要执行代码，那么难免会对整个 gc 环境产生破坏性的影响。由于没有析构函数，这些语言就不可能做到 RAII ，也就是说，它们的 gc 所能够管理的，也就仅仅只有内存而已了。对于其他资源， Java 等就必须手动释放。虽然 C# 提供了 with 关键字来缓解这一问题，但仍然无法彻底的解决。

还有什么麻烦呢？之前说的那 4 点全部都有。虽然 JVM 的速度在不断的提高，但是内存使用这一点却完全没有发展，不能不说是 gc 说导致。它所带来了什么好处呢？是内存管理的自动化，而不是资源管理的自动化。

所以说 C++ 并不是世人所想象的那样需要 gc ， C++ 本身就已经提供了足够强大的资源管理能力。基于栈的自动管理，或者使用引用计数，几乎可以达到和 gc 同样的覆盖面，而且没有 gc 的那些问题， RAII 使得 C++ 在管理非内存资源的时候还更加有优势，为什么不使用呢？

ps. 设计一个非官方的 gc 库还是可以的。但是毕竟不会成为主流了。

用法举例
bit_mask<INT_LIST_2(2, 3)>::value返回一个值，该值的第2、3位被置为1
其余位为0

sample

#include  < iostream >
#include  " multi_bit_mask.h "
using   namespace  std;
int  main()
{
    cout  <<  multi_bit_mask::bit_mask < INT_LIST_1( 1 ) > ::value  <<  endl;
    cout  <<  multi_bit_mask::bit_mask < INT_LIST_5( 0 ,  1 ,  2 ,  3 ,  4 ) > ::value  <<  endl;
    cout  <<  multi_bit_mask::bit_mask < INT_LIST_7( 0 ,  1 ,  2 ,  3 ,  4 ,  4 ,  2 ) > ::value  <<  endl;
    

    在vc下，使用typeid的时候，如果typeid施加给的类型是没有vptr的class或者根本不是class
那么汇编是
mov  dword ptr [addr],offset A `RTTI Type Descriptor' (42AD40h)
也就是编译器生成一个简单的type_info对象的表，并且在编译期静态决定下标，做一个简单查表操作。

如果typeid的操作对象是具有vptr的class，但是并不是一个引用或者指针的解引用形式，例如

A a;
typeid(a);

那么仍然仅仅会做查表操作


如果typeid的操作对象是具有vptr的class，并且是引用或者指针的解引用形式，例如

A  * p  =   new  A;
A &  r  =   * p;
typeid( * p);
typeid(r);

那么就会调用一个叫___RTtypeid的函数，并通过某种方法来获取type_info对象
下面是___RTtypeid的反汇编，这里只列出关键的几条指令

0041213E  mov         ecx,dword ptr [inptr]    ；inptr是对象的地址
00412141   mov         edx,dword ptr [ecx] 
00412143   mov         eax,dword ptr [edx - 4 ] 
0041215F  mov         ecx,dword ptr [eax + 0Ch] 
00412162   mov         dword ptr [ebp - 48h],ecx 
0041216C  mov         eax,dword ptr [ebp - 48h] 

基本上等价于C语言的

int  a1  =  ( int )p;  // p是对象的地址
int  a2  =   * ( int * )a1  -   4 ;
int  a3  =   * ( int * )a2  +   12 ;
int  a4  =   * ( int * )a3;

那么从这段代码可以看出vc下type_info对象的存放位置[如下图]

也就虚表下标为-1的位置上存放了一个指向一个未知的表的指针(暂且将此表命名为runtime_info_table)
runtime_info_table的第4格上存放了type_info对象的地址
至于runtime_info_table里前3格上存放的是什么, 还需要再研究研究
一般来说它们全是0, 但是对于多重虚继承的类, 第二格上会是4, 可能和指针的偏移量有关.

这是使用Xpressive动态语义定义的例子，其中sregex::compile函数编译一个表示正则文法的串，并返回一个正则对象sregex
使用regex_match来使用这个正则对象匹配一个串。结果储存在what内
其中what[0]返回整个串，what[1]~what[n]返回文法中用于标记的部分(用小括号括起来的部分)
最后将输出
     hello world!
     hello
     world

如果想在一个串中查找符合该文法的子串，可以使用regex_search，用法和regex_match一样，此外还可以用regex_replace来进行替换。

静态文法：
Xpressive除了可以用compile来分析一个文法串之外，还可以用类似于Spirit的方式来静态的指定文法：

sregex re = '$' >> +_d >> '.' >> _d >> _d;

这将定义一个表示金额的串，其中_d表示一个数字，相当于串 $\d+.\d\d
这样定义文法将比之前的动态定义更加高效，并且还有一个附加的好处：
分级定义：

sregex re = '$' >> +_d >> '.' >> _d >> _d;
sregex s = '(' >> re >> ')';

这样s表示为用括号括起来的re
通过分级定义，文法能被表示的更加清楚。
更加棒的是，分级定义还可以向后引用，因此能够分析EBNF

sregex group, factor, term, expression;
group       = '(' >> by_ref(expression) >> ')';
factor      = +_d | group;
term        = factor >> *(('*' >> factor) | ('/' >> factor));
expression  = term >> *(('+' >> term) | ('-' >> term));

expression定义了一个四则表达式，注意其中group的定义。
这里必须使用by_ref是因为Xpressive默认是值拷贝，如果这里使用默认的方式，那么会造成一个无限循环。


Xpressive可以在这里下载
http://boost-consulting.com/vault/index.php?PHPSESSID=f1d4af8b742cfa7adae7aab373cfc535&direction=0&order=&directory=Strings%20-%20Text%20Processing&PHPSESSID=f1d4af8b742cfa7adae7aab373cfc535
内有详细的文档

很多时候写一个类的时候，需要多个模版参数，例如一个遗传算法的算法类，需要一个模版参数来指定交配方式，另一个模版参数来指定子代选择的方式，还要一个参数来指定变异的方式。那么一般来说，这个类会写成：

template<class T                                                //描述问题的一个类
        , class CrossPolicy = AvgCrossPolicy                        //杂交方式
        , class SelectPolicy = DefaultSelectPolicy                //子代选择的方式
        , class VariationPolicy = ReverseVariationPolicy>        //变异方式
class Gene
        : private AvgCrossPolicy
        , private SelectPolicy
        , private VariationPolicy
{
        ....
};

这样用户要使用该类的时候，可以直接指定T，就行了，然而如果要指定变异方式，那么就必须把所有的参数都显式的写出来，很不方便

546提供了一种有效的方法，可以让我们仅仅指定变异参数，而不用写出另两个Policy
甚至允许我们以任意的顺序书写几个Policy参数，都不会有问题

预备知识:
TypeList
一个TypeList是一个类型的容器
template <typename Type_, typename Next_>
struct TypeList
{
        typedef Type_ Type;
        typedef Next_ Next;
};
这就是一个TypeList。
看这个写法，是不是像一个链表？
首先定义一个类型来表示链表尾：class NullType{};
现在一个包含了2个类型的TypeList就可以写为：
TypeList<T1, TypeList<T2, NullType>  >

如何在一个TypeList中查找一个类型的子类？
首先要有一个IsDerivedFrom<Base, T>
这个比较简单
template<class Base, class T>
class IsDerivedFrom
{
        struct large{char a[2];};
        static char pred(Base*);
        static large pred(...);
public:
        enum {Is = sizeof(pred((T*)0)) == sizeof(char)};
};

然后FindChild就容易了
template <class List, class Base>
struct FindChild
{
        template <bool IsChild>
        struct Select
        {
                typedef typename List::Type Type;
        };

        template <>
        struct Select<false>
        {
                typedef typename FindChild<typename List::Next, Base>::Type Type;
        };

        typedef typename Select<IsDerivedFrom<Base, typename List::Type> >::Type Type;
};

当然还要对一些特殊情况进行特化，例如NullType
template <class Base>
struct FindChild<NullType, Base>
{
        typedef NullType Type;
};
这里使用NullType来表明没找到

实际操作：
首先需要给3个Policy3个基类，分别叫
class AvgCrossPolicyBase{};
class SelectPolicyBase{};
class VariationPolicyBase{};
内容为空就行了，这样也没有虚函数调用的开销

然后声明一个类来表示默认情况：
class DefaultPolicy{};

定义一个宏
#define TYPELIST_3_N(a, b, c) TypeList<a, TypeList<b, TypeList<c, NullType> > >

下面要写一些选择器,用于把合适的类型选择出来，如果没找到，则要使用默认的类型
template <class List, class Base, class DefaultType>
struct Selector
{
        template <class RetType>
        struct Judge
        {
                typedef RetType Type;
        };
       
        template<>
        struct Judge<NullType>
        {
                typedef DefaultType Type;
        };
        typedef typename Judge<typename FindChild<List, Base>::Type >::Type Type;
};

好啦，现在整个类的声明可以写为

template<class T
        , class CrossPolicy_ = DefaultPolicy
        , class SelectPolicy_ = DefaultPolicy
        , class VariationPolicy_ = DefaultPolicy     //其后的参数用户不可指定
        , class List = TYPELIST_3_N(CrossPolicy_, SelectPolicy_, VariationPolicy_)
        , class CrossPolicy = typename Selector<List, CrossPolicyBase,  AvgCrossPolicy>::Type
        , class SelectPolicy = typename Selector<List,  SelectPolicyBase,  DefaultSelectPolicy>::Type
        , class VariationPolicy = typename Selector<List,  VariationPolicyBase,  ReverseVariationPolicy>::Type
        >
class Gene
        : private CrossPolicy
        , private SelectPolicy
        , private VariationPolicy
{
       
        ....
};

其中第4-7个参数（List，CrossPolicy，SelectPolicy和VariationPolicy）是不由用户指定的，仅仅是为了起一个别名
第一个参数T必须指定，然后2，3，4这3个参数就可以任意的改变顺序了
例如，可以写Gene<T, DefaultSelectPolicy, AvgCrossPolicy>而不会有任何问题
如果不想要最后面几个参数的话也行，但是代码就要稍微长一点
而且最好在类里面进行3个typedef
typedef typename Selector<List, CrossPolicyBase,  AvgCrossPolicy>::Type CrossPolicy;
等，以便在实现的时候使用

   rule<> group, factor, term, exp;
   group  = '(' >> exp >> ')';
   factor = int_p | group;
   term   = factor >> *(('*' >> factor) | ('/' >> factor));
   exp    = term >> *(('+' >> term) | ('-' >> term));

这里使用=代替::=, 用>>代替空格连接。并且由于C++语法所限，EBNF中后置的*在spirit中改为前置。
等式左边的单词被称为一个rule，等式右边为rule的定义。我们可以看出一个group是一个exp加上一对括号，一个factor是一个整数或者一个group,一个term是一个或多个factor用*/连接，一个exp是一个或多个term用+-连接。处于最顶端的exp可以据此识别出以下表达式
   

   12345
   -12345
   +12345
   1 + 2
   1 * 2
   1/2 + 3/4
   1 + 2 + 3 + 4
   1 * 2 * 3 * 4
   (1 + 2) * (3 + 4)
   (-1 + 2) * (3 + -4)
   1 + ((6 * 200) - 20) / 6
   (1 + (2 + (3 + (4 + 5))))

    得到一个rule之后，我们就可以用 parse函数对一个串进行识别了。例如
         

该函数返回一个结构parse_info，可以通过访问其中的full成员来判断是否成功识别，也可以访问stop成员来获知失败的位置。这里要特别提一点，关于各个符号之间的空格，spirit的文档的正文说的是给parse再传一个参数space_p，通知parse跳过所有的空格，然而在FAQ中又提到，如果使用以上方法定义rule，第三个参数传space_p会失败。原因是使用rule默认定义的规则被称为character level parsing，即字符级别解析，而parse的第3个参数仅适用于phrase level parsing，即语法级别解析。要使用第3个参数可以有几种方法。
      1。在parse的第二个参数直接传入一个EBNF表达式，不创建rule对象。
         

      2。以rule<phrase_scanner_t>创建rule。
         

注意虽然可以用这两个办法屏蔽空格，但是这样可能完全改变EBNF文法的语义，尤其是在语言本身需要识别空格的时候。对于这种情况，可以不使用第三个参数，并在需要出现空格的地方加上space_p,或者+space_p及*space_p，其中+和*分别表示后面的符号连续出现一次以上和0次以上。例如一个以空格分隔的整数列表可以写成int_p >> *(+space_p >> int_p)
   如上使用parse可以识别一个串，但并不能做更多的操作，例如将语法里的各个成分提取出来。对于这样的需求，可以通过actor实现。下面是使用actor的一个简单例子
   

   bool
   parse_numbers(char const* str, vector<double>& v)
   {
      return parse(str,

   //  Begin grammar
      (
         real_p[push_back_a(v)] >> *(',' >> real_p[push_back_a(v)])
      )
      ,
      //  End grammar
      space_p).full;
   }

注意到real_p后面的[]，中括号里面是一个仿函数（函数指针或者函数对象），该仿函数具有如下调用型别
   

   void operator()(IterT first, IterT last) const;
   void operator()(NumT val) const;
   void operator()(CharT ch) const;

一旦spase发现了匹配real_p的子串，就会调用该functor。不同的rule可能会对应不同的调用型别。
第一个型别针对一般规则，first和last为两个指向字符的迭代器（一般为char*）,匹配的子串为[first, last)
第二个型别针对数字型规则，如real_p和int_p, 参数val是一个数字类型。
第三个性别针对单字符型规则，如space_p, 参数ch是一个字符类型。
real_p[push_back_a(v)]中的push_back_a是一个spirit已经定义好的functor，它会将匹配好的内容依照匹配到的时间顺序调用v的push_back函数加入到v中。

   到此spirit的常用功能就都介绍完了。要详细深入了解可以参考spirit的文档。

最后在题一个注意要点。spirit的各种EBNF连接都是指针连接，因此才能在expression被赋值前就在group的定义里面使用。所以在使用EBNF的时候一定要小心不要将局部变量的rule提供给全局或者类成员变量使用，例如：
   

   class A
   {
      rule<> s;
      A()
      {
         rule<> r = int_p | hex_p;

         s = r >> *(+space_p >> r); //error, r destructed after return 
      }
   };

如果真想使用局部作用域，可以在局部的rule前面加上static.