欧美日韩视频一区二区三区,老司机一区二区三区,亚洲国产精品久久久久久女王

shifan3 — Fri, 02 Nov 2007 10:05:00 GMT

转蝲自神的blog
http://blog.csdn.net/vbvan/archive/2007/10/30/1857134.aspx

Flexible C++

C++是一门非常灵�zȝ��语言�Q�只要充分发挥你的想象，再普通的东西都能玩出新花�?br>
1�?~1000求和
循环�Q�递归�Q�再��单不�q�的题目了。但是如果不允许你用判断语句呢？
如果你熟悉switch的内部实玎ͼ�那么你很�Ҏ��惛_��使用函数指针数组�?br>

#include

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));
}

2、输�?,2,...,100,99,...,2,1
如果同样不让你用判断语句呢？你仍然可以��用函数指针数�l�：

#include

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);
}

不过我们有更��z�的�Ҏ��?br>短�\��法和逗号表达式粉墨登��Z��Q�一行搞定~

#include

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);
}

shifan3 2007-11-02 18:05 发表评论

[yc]用户态非抢占式线�E�库实现

shifan3 — Fri, 16 Mar 2007 08:33:00 GMT

摘要: �q�_�� i386 �Q?win32 �Q?msvc 2003 代码��单介�l�：调度��法�Q�轮转法。。，可修�? 内存模型�Q�每个线�E�拥有各自独立的堆栈。启动线�E�的时候，切换到对应的堆栈再启动，使得�U�程之间的堆栈互不干�? 调度方式�Q�线�E�调�?schedule 函数�Q?schedule �?setjmp 保存当前堆栈�Q�选择一�?.. 阅读全文

shifan3 2007-03-16 16:33 发表评论

[yc]垃圾回收�Q�C++资源��理杂谈

shifan3 — Wed, 24 Jan 2007 10:02:00 GMT

说到 C/C++ 的资源管理，��Z�h都会头痛半天。自�?/span> C++0x �Q�就�?/span> C++09 了）标准漏出风声之后�Q?/span> C++ 标准是否会引入自动垃圑֛�收机制就成�ؓ了众�?/span> C++ 爱好者谈论的话题。但是实际上�Q�在 C++ 标准的探索上�Q�垃圑֛�收一直处在一个十分低下的��C��。造成其这一处境的原因很多，也很复杂。我们来看看站在 C++ �E�序员的角度上看�Q�资源管理机制现在所面��的局�ѝ�?/span>

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

首先��要的介绍一�?/span> RAII �?/span> RAII 的全�U�是 Resource Acquisition Is initialization 。这个思想的基本手法是对于一�U�想要��用的资源�Q��ؓ其书写一�?/span> guard �c�，在该�cȝ��构造函数里�q�行资源的请求，在析构函数里�q�行资源的释放。例如假设我们想��理一个互斥锁�Q�可能的方式是：

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

此后�Q�对�q�个对象使用什么内存管理方式，也就�{��h于对�q�个互斥锁��用什么内存管理方式�?/p>

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

回到内存模型来看�Q�有一点让我们无法��内存与其它资源�{�同�Q�反�q�来�Q�把其它资源和内存等同却是可以的�Q�，那就是��@环引用�?/span> A 内存可以持有指向 B 内存的引用， B 内存也可以反�q�来持有 A 内存的引用。��@环引用导致内存管理不可以�?#8220;是否有指向该内存的引�?#8221;来区分一块内存是否可以回收。从而��׃��一个绝佳的��理手段。但是在没有循环引用的场合下�Q�我们还是有非常��z�高效的��理�Ҏ��的。那��是引用计数�?/span>

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

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

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

1�Q?/font> 你无法却知对象析构的具体旉��Q�从而无法真正知道媄响程序性能的瓶颈在什么地斏V�?/span>

2�Q?/font> gc 都們֐�于大量的使用内存�Q�直到内存不够的时候再�q�行清理�Q�这样会��D��E�序的内存用量严重颠��，�q�且产生大量的换��c�?/span>

3�Q?/font> �q�度的依赖于 gc 会�ɽE�序员大量的把可以由之前提到的各�U�方法来处理的资源交�l?/span> gc 来处理，无故的加重了 gc 的负担�?/span>

4�Q?/font> gc 的管理方法和 C++ 的析构函数有可能产生语义上的冲突�?/span>

�q�就是�ؓ什�?/span> C++ 标准对垃圑֛�收的态度如此恶劣的原因�?/span>

我们现在回过头来�?/span> Java/C# �q�样的内�|?/span> gc 的语�a�。这��L��语言�׃��使用�?/span> gc �Q�就不可避免的放弃了析构函数。�ؓ什�?/span> gc 会和析构函数产生冲突呢？一�?/span> gc 一般会希望在进行垃圑֛�收的时候，整个�q�程是一个原子的�Q�但析构函数会破坏这一点，在释攑ֆ�存的时候如果还要执行代码，那么隑օ�会对整个 gc 环境产生破坏性的影响。由于没有析构函敎ͼ��q�些语言��׃��可能做到 RAII �Q�也��是��_��它们�?/span> gc 所能够��理的，也就仅仅只有内存而已了。对于其他资源， Java �{�就必须手动释放。虽�?/span> C# 提供�?/span> with 关键字来�~�解�q�一问题�Q�但仍然无法��d��的解冟�?/span>

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

所以说 C++ �q�不是世人所惌��的那样需�?/span> gc �Q?/span> C++ 本��n��已�l�提供了��_��强大的资源管理能力。基于栈的自动管理，或者��用引用计敎ͼ�几乎可以辑ֈ��?/span> gc 同样的覆盖面�Q�而且没有 gc 的那些问题， RAII 使得 C++ 在管理非内存资源的时候还更加有优势，��Z��么不使用呢？

ps. 设计一个非官方�?/span> gc 库还是可以的。但是毕竟不会成��Z��了�?/span>

shifan3 2007-01-24 18:02 发表评论

[yc]详解link

shifan3 — Fri, 05 Jan 2007 08:03:00 GMT

详解link
有些人写C/C++(以下假定为C++)�E�序�Q�对unresolved external link或者duplicated external simbol的错误信息不知所措（因�ؓ�q�样的错误信息不能定位到某一行）。或者对语言的一些部分不知道��Z��么要�Q�或者不要）�q�样那样设计。了解本文之后，或许会有一些答案�?br>    首先看看我们是如何写一个程序的。如果你在��用某�U�IDE�Q�Visual Studio�Q�Elicpse�Q�Dev C++�{�）�Q�你可能不会发现�E�序是如何组�l��v来的�Q�很多�h因此而反对初学者��用IDE�Q�。因��Z��用IDE�Q�你所做的事情�Q�就是在一个项目里新徏一�p�d��?cpp�?h文�g�Q�编写好之后在菜单里点击“�~�译”�Q�就万事大吉了。但其实以前�Q�程序员写程序不是这��L��。他们首先要打开一个编辑器�Q�像�~�写文本文�g一��L��写好代码�Q�然后在命��o行下�?br>   cc 1.cpp -o 1.o
   cc 2.cpp -o 2.o
   cc 3.cpp -o 3.o
�q�里cc代表某个C/C++�~�译器，后面紧跟着要编译的cpp文�g�Q��ƈ且以-o指定要输出的文�g�Q�请原谅我没有��用�Q何一个流行编译器作�ؓ例子�Q�。这样当前目录下��׃��出现�Q?br>   1.o 2.o 3.o
最后，�E�序员还要键�?br>   link 1.o 2.o 3.o -o a.out
来生成最�l�的可执行文件a.out。现在的IDE�Q�其实也同样�늅�着�q�个步骤�Q�只不过把一切都自动化了�?br>    让我们来分析上面的过�E�，看看能发��C��么�?br>    首先�Q�对源代码进行编译，是对各个cpp文�g单独�q�行的。对于每一�ơ编译，如果排除在cpp文�g里include别的cpp文�g的情况（�q�是C++代码�~�写中极光��误的写法�Q�，那么�~�译器仅仅知道当前要�~�译的那一个cpp文�g�Q�对其他的cpp文�g的存在完全不知情�?br>    其次�Q�每个cpp文�g�~�译后，产生�?o文�g�Q�要被一个链接器(link)所��d��Q�才能最�l�生成可执行文�g�?br>    好了�Q�有了这些感性认识之后，让我们来看看C/C++�E�序是如何组�l�的�?br>
    首先要知道一些概念：
    �~�译�Q�编译器�Ҏ��代码�q�行�~�译�Q�是��以文本形式存在的源代码��译为机器语�a�形式的目标文件的�q�程�?br>    �~�译单元�Q�对于C++来说�Q�每一个cpp文�g��是一个编译单元。从之前的编译过�E�的演示可以看出�Q�各个编译单元之间是互相不可知的�?br>    目标文�g�Q�由�~�译所生成的文�Ӟ��以机器码的�Ş式包含了�~�译单元里所有的代码和数据，以及一些其他的信息�?br>
    下面我们具体看看�~�译的过�E�。我们蟩�q�语法分析等�Q�直接来到目标文件的生成。假设我们有一�?.cpp文�g
    int n = 1;

   void f()
    {
       ++n;
   }

    它编译出来的目标文�g1.o��׃��有一个区域（假定名称�?�q�制�D�）�Q�包含了以上数据�Q�函敎ͼ�其中有n, f�Q�以文�g偏移量的形式�l�出很可能就是：
   偏移�?nbsp; 内容   长度
   0x000   n   4
   0x004   f    ??
    注意�Q�这仅仅是猜��，不代表目标文件的真实布局。目标文件的各个数据不一定连�l�，也不一定按照这个顺序，当然也不一定从0x000开始�?br>    现在我们看看�?x004开始f函数的内容（�?x86�q�_��下的猜测�Q�：
   0x004 inc DWORD PTR [0x000]
   0x00? ret
    注意n++已经被翻译�ؓ�Q�inc DWORD PTR [0x000]�Q�也��是把本单元0x000位置上的一个DWORD(4字节)�?�?br>
    下面如果有另一�?.cpp�Q�如�?br>   extern int n;
   void g()
   {
       ++n;
   }
    那么它的目标文�g2.o�?�q�制�D�就应该�?br>   偏移�?nbsp; 内容   长度
   0x000   g    ??
    ��Z��么这里没有n的空��_��也就是n的定义）�Q�因为n被声明�ؓextern�Q�表明n的定义在别的�~�译单元里。别忘了�~�译的时候是不可能知道别的编译单元的情况的，故编译器不知道n�I�竟在何处，所以这个时候g的二�q�制代码里没有办法填写inc DWORD PTR [???]中的�Q�？�Q�部分。怎么办呢�Q�这个工作就只能交给后来的链接器��d��理。�ؓ了让链接器知道哪些地方的地址是没有填好的�Q�所以目标文件还要有一�?#8220;未解决符可��”�Q�也��是unresolved symbol table. 同样,提供n的定义的目标文�g(也就�?.o)也要提供一�?#8220;导出�W�号�?#8221;�Q�export symbol table, 来告诉链接器自己可以提供哪些地址�?br>    让我们理一下思�\�Q�现在我们知道，每一个目标文�Ӟ��除了拥有自己的数据和二进制代码之外，�q�要臛_��提供2个表�Q�未解决�W�号表和导出�W�号表，分别告诉链接器自己需要什么和能够提供什么。下面的问题是，如何�?个表之间建立对应关系。这里就有一个新的概念：�W�号。在C/C++中，每一个变量和函数都有自己的符受��例如变量n的符号就�?#8220;n”。函数的�W�号要更加复杂，它需要结合函数名及其参数和调用惯例等�Q�得��C��个唯一的字�W�串。f的符号可能就�?_f"�Q�根据不同编译器可以有变化）�?br>    所以，1.o的导出符可��是
   �W�号   地址
   n   0x000
   _f   0x004
    而未解决�W�号表�ؓ�I?br>    2.o的导出符可��?br>   �W�号   地址
   _g   0x000
    未解决符可��?br>   �W�号   地址
   n   0x001
    �q�里0x001��Z��0x000开始的inc DWORD PTR [???]的二�q�制�~�码中存�???的�v始地址(�q�里假设inc的机器码的第2�Q?字节��+1的绝对地址�Q�需要知道确切情况可查手�?。这个表告诉链接器，在本�~�译单元0x001的位�|�上有一个地址�Q�该地址��g��明，但是��h��W�号n�?br>    链接的时候，链接器在2.o里发��C��未解决符号n�Q�那么在查找所有编译单元的时候，�?.o中发��C��导出�W�号n�Q�那么链接器��׃��n的地址0x000填写�?.o�?x001的位�|�上�?br>    “打住”�Q�可能你��׃��跛_��来指责我了。如果这样做得话�Q�岂不是g的内容就会变成inc DWORD PTR [0x000]�Q�按照之前的理解�Q�这是将本单元的0x000地址�?字节�?�Q�而不是将1.o的对应位�|�加1。是的，因�ؓ每个�~�译单元的地址都是�?开始的�Q�所以最�l�拼接�v来的时候地址会重复。所以链接器会在拼接的时候对各个单元的地址�q�行调整。这个例子中�Q�假�?.o�?x00000000地址被定位在可执行文件的0x00001000上，�?.o�?x00000000地址被定位在可执行文件的0x00002000上，那么实际上对链接器来��_��1.o的导出符可��其实
   �W�号   地址
   n   0x000 + 0x2000
   _f   0x004 + 0x2000
    而未解决�W�号表�ؓ�I?br>    2.o的导出符可��?br>   �W�号   地址
   _g   0x000 + 0x1000
    未解决符可��?br>   �W�号   地址
   n   0x001 + 0x1000
所以最�l�g的代码会变�ؓinc DWORD PTR [0x000 + 0x2000]�?br>    最后还有一个漏�z�，既然最后n的地址变�ؓ0x2000了，那么以前f的代码inc DWORD PTR [0x000]��是错误的了。所以目标文件�ؓ此还要提供一个表�Q�叫做地址重定向表address redirect table�?br>    对于1.o来说�Q�它的重定向表�ؓ
   地址
   0x005
    �q�个表不需要符��P��当链接器处理�q�个表的时候，发现地址�?x005的位�|�上有一个地址需要重定向�Q�那么直接在�?x005开始的4个字节上加上0x2000��可以了�?br>    让我们�ȝ��一下：�~�译器把一个cpp�~�译为目标文件的时候，除了要在目标文�g里写入cpp里包含的数据和代码，�q�要臛_��提供3个表�Q�未解决�W�号表，导出�W�号表和地址重定向表�?br>    未解决符可��提供了所有在该编译单元里引用但是定义�q�不在本�~�译单元里的�W�号及其出现的地址�?br>    导出�W�号表提供了本编译单元具有定义，�q�且愿意提供�l�其他编译单元��用的�W�号及其地址�?br>    地址重定向表提供了本�~�译单元所有对自��n地址的引用的记录�?br>    链接器进行链接的时候，首先军_��各个目标文�g在最�l�可执行文�g里的位置。然后访问所有目标文件的地址重定向表�Q�对其中记录的地址�q�行重定向（卛_��上该�~�译单元实际在可执行文�g里的起始地址�Q�。然后遍历所有目标文件的未解决符可��Q��ƈ且在所有的导出�W�号表里查找匚w��的符��P��q�在未解决符可��中所记录的位�|�上填写实际的地址�Q�也要加上拥有该�W�号定义的编译单元实际在可执行文仉��的�v始地址�Q�。最后把所有的目标文�g的内容写在各自的位置上，再作一些别的工作，一个可执行文�g��出炉了�?br>    最�l�link 1.o 2.o .... 所生成的可执行文�g大概�?br>   0x00000000 ????�Q�别的一些信息）
   ....
   0x00001000 inc DWORD PTR [0x00002000]             //�q�里�?.o的开始，也就是g的定�?br>   0x00001005 ret                                 //假设inc�?个字节，�q�里是g的结��?br>   ....
   0x00002000 0x00000001                          //�q�里�?.o的开始，也是n的定义（初始化�ؓ1�Q?br>   0x00002004 inc DWORD PTR [0x00002000]      //�q�里是f的开�?br>   0x00002009 ret                                 //假设inc�?个字节，�q�里是f的结��?br>   ...
   ...
    实际链接的时候更为复杂，因�ؓ实际的目标文仉��把数据／代码分�ؓ好几个区�Q�重定向�{�要按区�q�行�Q�但原理是一��L��?br>


    现在我们可以来看看几个经典的链接错误了：
   unresolved external link..
   �q�个很显�Ӟ��是链接器发现一个未解决�W�号�Q�但是在导出�W�号表里没有扑ֈ�对应的項�?br>   解决�Ҏ��么，当然��是在某个编译单元里提供�q�个�W�号的定义就行了。（注意�Q�这个符号可以是一个变量，也可以是一个函敎ͼ��Q�也可以看看是不是有什么该链接的文件没有链�?br>   duplicated external simbols...
   �q�个则是导出�W�号表里出现了重复项�Q�因此链接器无法��定应该使用哪一个。这可能是��用了重复的名�U�ͼ�也可能有别的原因�?br>

    我们再来看看C/C++语言里针对这一些而提供的�Ҏ��：
   extern:�q�是告诉�~�译器，�q�个�W�号在别的编译单元里定义�Q�也��是要把�q�个�W�号攑ֈ�未解决符可��里去。（外部链接�Q?br>
   static:如果该关键字位于全局函数或者变量的声明的前面，表明该编译单元不导出�q�个函数�Q�变量的�W�号。因此无法在别的�~�译单元里��用。（内部链接�Q�。如果是static局部变量，则该变量的存储方式和全局变量一��P��但是仍然不导出符受��?br>
   默认链接属性：对于函数和变量，模认外部链接�Q�对于const变量�Q�默认内部链接。（可以通过��d��extern和static改变链接属性）

   外部链接的利弊：外部链接的符��P��可以在整个程序范围内使用�Q�因为导��Z��W�号�Q�。但是同时要求其他的�~�译单元不能导出相同的符��P��不然��是duplicated external simbols)

   内部链接的利弊：内部链接的符��P��不能在别的编译单元内使用。但是不同的�~�译单元可以拥有同样名称的内部链接符受��?br>
   ��Z��么头文�g里一般只可以有声明不能有定义�Q�头文�g可以被多个编译单元包含，如果头文仉��有定义，那么每个包含�q�个头文件的�~�译单元��都会对同一个符可��行定义，如果该符号�ؓ外部链接�Q�则会导致duplicated external simbols。因此如果头文�g里要定义�Q�必��M��证定义的�W�号只能��h��内部链接�?br>
   ��Z��么常量默认�ؓ内部链接�Q�而变量不是：
       �q�就是�ؓ了能够在头文仉��如const int n = 0�q�样的定义常量。由于常量是只读的，因此即��每个�~�译单元都拥有一份定义也没有关系。如果一个定义于头文仉��的变量拥有内部链接，那么如果出现多个�~�译单元都定义该变量�Q�则其中一个编译单元对该变量进行修改，不会影响其他单元的同一变量�Q�会产生意想不到的后果�?br>
   ��Z��么函数默认是外部链接�Q?br>       虽然函数是只�ȝ��Q�但是和变量不同�Q�函数在代码�~�写的时候非常容易变化，如果函数默认��h��内部链接�Q�则��Z��会們֐�于把函数定义在头文�g里，那么一旦函数被修改�Q�所有包含了该头文�g的编译单元都要被重新�~�译。另外，函数里定义的静态局部变量也��被定义在头文�g里�?br>
   ��Z��么类的静态变量不可以��地初始化：所谓就地初始化��是�c�M��于这��L��情况�Q?br>       class A
       {
           static char msg[] = "aha";
       };
不允许这样做得原因是�Q�由于class的声明通常是在头文仉��Q�如果允许这样做�Q�其实就相当于在头文仉��定义了一个非const变量�?br>
   在C++里，头文件定义一个const对象会怎么��P��
       一般不会怎么��P��q�个和C里的在头文�g里定义const int一��P��每一个包含了�q�个头文件的�~�译单元都会定义�q�个对象。但�׃��该对象是const的，所以没什么媄响。但是：�?�U�情况可能破坏这个局面：
       1。如果涉及到对这个const对象取地址�q�且依赖于这个地址的唯一性，那么在不同的�~�译单元里，取到的地址可以不同。（但一般很��这么做�Q?br>       2。如果这个对象具有mutable的变量，某个�~�译单元对其�q�行修改�Q�则同样不会影响到别的编译单元�?br>
   ��Z��么类的静态常量也不可以就地初始化�Q?br>       因�ؓ�q�相当于在头文�g里定义了const对象。作��Z��外，int/char�{�可以进行就地初始化�Q�是因�ؓ�q�些变量可以直接被优化�ؓ立即敎ͼ��和宏一栗��?br>
   内联函数�Q?br>       C++里的内联函数�׃��c�M��于一个宏�Q�因此不存在链接属性问题�?br>
   ��Z��么公�׃��用的内联函数要定义于头文仉��Q?br>       因�ؓ�~�译时编译单元之间互�怸�知道�Q�如果内联函数被定义�?cpp文�g中，�~�译其他使用该函数的�~�译单元的时候没有办法找到函数的定义�Q�因此无法对函数�q�行展开。所以说如果内联函数定义�?cpp文�g里，那么��只有这个cpp文�g可以是用�q�个函数�?br>
   头文仉��内联函数被拒�l�会怎样�Q?br>       如果定义于头文�g里的内联函数被拒�l�，那么�~�译器会自动在每个包含了该头文�g的编译单元里定义�q�个函数�q�且不导出符受��?br>
   如果被拒�l�的内联函数里定义了静态局部变量，�q�个变量会被定义于何处：
       早期的编译器会在每个�~�译单元里定义一个，�q�因此��生错误的�l�果�Q�较新的�~�译器会解决�q�个问题�Q�手�D�|��知�?br>
   ��Z��么export关键字没人实玎ͼ�
       export要求�~�译器跨�~�译单元查找函数定义�Q��得编译器实现非常困难�?br>

�~�译和静态链接就分析到这里，我会带着动态链接和load的详解杀回来

shifan3 2007-01-05 16:03 发表评论

shifan3 — Wed, 27 Dec 2006 03:04:00 GMT

摘要: 1。符��h��找（对于函数此时只看名字�Q�不看参敎ͼ� 大致��序�?nbsp; (1)如果有限定名( XXX:: )那么��q��接在XXX里查�?nbsp; (2)函数局部名字空�?nbsp; (3)(如果是成�?�c�d��字空�?nbsp; (4)递归向上��x��有基�cȝ��... 阅读全文

shifan3 2006-12-27 11:04 发表评论

[yc]伪typeof

shifan3 — Thu, 21 Dec 2006 06:29:00 GMT

发信�? shifan (学习��云技�?, 杉K��: C++
�?nbsp; �? 伪typeof
发信�? 飘�ؓ水云�?(Tue Dec 19 16:38:45 2006), 转信

1 /*
2 用标准C++实现typeof是不可能�?br> 3 �q�个是我写的一个approached typeof
4 所有需要被静态反��出来的�c�d��必须先用DECL_TYPE注册
5 模板如果仅仅带有1个参数可以用DECL_TEMPLATE_1注册
6 多个参数的模板还不支持。�?br> 7 主要是没惛_��~�码
8
9 ��d��能注�?4个类�?br>10 可以通过MAX_TYPE_NUMBER讄��
11
12 支持的模板嵌套层数大�U��ؓ32 �Q?nbsp;log2(MAX_TYPE_NUMBER)
13 MAX_TYPE_NUMBER必须�?的整�ơ数�q?br>14 */
15 namespace my_typeof
16 {
17
18   const int MAX_TYPE_NUMBER = 64;
19
20   template <int N>
21   struct dummy
22   {
23     int a[N];
24   };
25
26
27   template <int N, typename Arg1>
28   struct select_by_number_1;
29
30   template <int N>
31   struct select_by_number
32   {
33     typedef typename select_by_number_1<N % MAX_TYPE_NUMBER, typename
34 select_by_number<N / MAX_TYPE_NUMBER>::type>::type type;
35   };
36
37
38   template <typename T>
39   struct number_of
40   {
41     static const int v = sizeof(generic_f(*(T*)0)) / sizeof(int);
42   };
43
44
45 #define DECL_TYPE(T, N) \
46   namespace my_typeof{  \
47   template<>\
48   struct select_by_number<N> \
49   {\
50     typedef T type;\
51   };\
52   dummy <N> generic_f(const T&);}
53
54
55 #define DECL_TEMPLATE_1(T, N) \
56   namespace my_typeof{        \
57   template<typename Arg1>\
58   struct select_by_number_1<N, Arg1>\
59   {\
60     typedef T<Arg1> type;\
61   };\
62   template <typename Arg1>\
63   dummy<N + number_of<Arg1>::v * MAX_TYPE_NUMBER > generic_f(const T<Arg1>&);}
64
65
66
67 #define TYPE_OF(x) my_typeof::select_by_number
68 sizeof (int)>::type
69
70 }
71
72
73 //sample
74 #include <iostream>
75 #include <vector>
76 #include <list>
77
78
79 DECL_TYPE(int, 1);
80 DECL_TEMPLATE_1(std::vector, 2);
81 DECL_TEMPLATE_1(std::list, 3);
82 DECL_TYPE(double, 4)
83
84 using namespace std;
85 int main(int, char*[])
86 {
87   vector<list<vector<list<double> > > > v1;
88   TYPE_OF(v1) v2;
89   v1 = v2;
90   return 0;
91 }
92
93

--
You well 撒法�Q�You well all 撒法�Q?br>
�?内容修改:·shifan �?Dec 21 14:21:57 修改本文内容·[FROM: shifan]
�?来源:·飘�ؓ水云�?freecity.cn·[FROM: shifan]

shifan3 2006-12-21 14:29 发表评论

[yc]Multi Bit Mask

shifan3 — Thu, 26 Oct 2006 15:37:00 GMT

boost的integer/integer_mask.hpp仅仅做了单个位的bit mask
要多个位必须写很多遍high_bit_mask_t
使用low_bits_mask_t也不能完全解决问�?br>所以自��q��Typelist的那�U�写法写了一�?/p>

用法举例
bit_mask::value�q�回一个��|��该值的�W?�?位被�|��ؓ1
其余位�ؓ0

  1
  2 namespace multi_bit_mask
  3 {
  4     namespace details
  5     {
  6
  7         template <typename T>
  8         struct get_size
  9         {
10             enum {size = sizeof(T)};
11         };
12
13         template <int Bit>
14         struct bit_storage
15         {
16             typedef typename bit_storage<Bit - 1>::storage_type storage_type;
17         };
18
19         //---------platform dependency-----------------------
20
21         typedef unsigned int smallest_storage_type;
22         typedef unsigned long long largest_storage_type;
23
24
25
26         template <>
27         struct bit_storage<0>
28         {
29             typedef smallest_storage_type storage_type;
30         };
31
32         template <>
33         struct bit_storage<get_size<smallest_storage_type>::size * 8>
34         {
35             typedef largest_storage_type storage_type;
36         };
37
38         //disable the 65th bit
39         template <>
40         struct bit_storage<get_size<largest_storage_type>::size * 8>
41         {
42             typedef void storage_type;
43         };
44
45         //---------end of platform dependency----------------
46
47
48         template <unsigned int N, typename Next>
49         struct int_list
50         {
51             typedef typename bit_storage<N>::storage_type storage_type;
52             static const storage_type value = N;
53             typedef Next next;
54         };
55
56         struct null_type{};
57
58         template<typename T1, typename T2, bool is_first>
59         struct selector
60         {
61             typedef T1 type;
62         };
63
64         template<typename T1, typename T2>
65         struct compare_type
66         {
67             const static bool is_larger = sizeof(T1) > sizeof(T2);
68             typedef typename selector<T1, T2, is_larger>::type large_type;
69             typedef typename selector<T1, T2, !is_larger>::type small_type;
70         };
71
72
73
74         template<typename T1, typename T2>
75         struct selector<T1, T2, false>
76         {
77             typedef T2 type;
78         };
79
80         template <typename List>
81         class find_largest_storage
82         {
83             typedef typename find_largest_storage<typename List::next>::storage_type T1;
84             typedef typename bit_storage<List::value>::storage_type T2;
85         public:
86             typedef typename compare_type<T1, T2>::large_type storage_type;
87         };
88
89         template <>
90         class find_largest_storage<null_type>
91         {
92         public:
93             typedef smallest_storage_type storage_type;
94         };
95
96
97     }
98
99
100
101
102
103     template <int N>
104     struct single_bit_mask
105     {
106         typedef typename details::bit_storage<N>::storage_type storage_type;
107         static const storage_type value
108             = static_cast<storage_type>(single_bit_mask<N - 1>::value) * 2;
109     };
110
111     template <>
112     struct single_bit_mask<0>
113     {
114         typedef details::bit_storage<0>::storage_type storage_type;
115         static const storage_type value = 1;
116     };
117
118
119     typedef details::null_type null_type;
120
121     template <int N, typename Next>
122     struct int_list_t : public details::int_list<N, Next> {};
123
124     template <typename List>
125     struct bit_mask
126     {
127     public:
128
129         typedef typename details::find_largest_storage<List>::storage_type storage_type;
130
131         static const storage_type value
132             = static_cast<storage_type>(single_bit_mask<List::value>::value)
133             | static_cast<storage_type>(bit_mask<typename List::next>::value);
134     };
135
136     template <>
137     struct bit_mask<null_type>
138     {
139         typedef details::bit_storage<0>::storage_type storage_type;
140         static const storage_type value = 0;
141     };
142
143
144
145
146
147     #define INT_LIST_1(n1) multi_bit_mask::int_list_t
148     #define INT_LIST_2(n1, n2) multi_bit_mask::int_list_t
149     #define INT_LIST_3(n1, n2, n3) multi_bit_mask::int_list_t
150     #define INT_LIST_4(n1, n2, n3, n4) multi_bit_mask::int_list_t
151     #define INT_LIST_5(n1, n2, n3, n4, n5) multi_bit_mask::int_list_t
152     #define INT_LIST_6(n1, n2, n3, n4, n5, n6) multi_bit_mask::int_list_t
153     #define INT_LIST_7(n1, n2, n3, n4, n5, n6, n7) multi_bit_mask::int_list_t
154     #define INT_LIST_8(n1, n2, n3, n4, n5, n6, n7, n8) multi_bit_mask::int_list_t
155
156 }
157
158
159

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;

shifan3 2006-10-26 23:37 发表评论

[yc]VC下typeid实现及内存布局分析

shifan3 — Thu, 26 Oct 2006 02:46:00 GMT

�q�日在学校bbs上与��论C++的typeid关键字的实现问题�Q�有人提到type_info的地址是存攑֜�虚表的第一个位�|�上�Q�颇觉得不妥�Q�于是我在vc2003下实验了一�?/p>

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

如果typeid的操作对象是��h��vptr的class�Q�但是�ƈ不是一个引用或者指针的解引用�Ş式，例如

A a;
typeid(a);

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

如果typeid的操作对象是��h��vptr的class�Q��ƈ且是引用或者指针的解引用�Ş式，例如

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

那么��׃��调用一个叫___RTtypeid的函敎ͼ��q��过某种�Ҏ��来获取type_info对象
下面是___RTtypeid的反汇编�Q�这里只列出关键的几条指�?br>

0041213E  mov         ecx,dword ptr [inptr]    �Q�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语言�?br>

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

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

也就虚表下标�?1的位�|�上存放了一个指向一个未知的表的指针(暂且��此表命名�ؓruntime_info_table)
runtime_info_table的第4��g��存放了type_info对象的地址
至于runtime_info_table里前3��g��存放的是什�? �q�需要再研究研究
一般来说它们全�?, 但是对于多重虚��承的�c? �W�二��g��会是4, 可能和指针的偏移量有�?

shifan3 2006-10-26 10:46 发表评论

shifan3 — Thu, 27 Jul 2006 08:27:00 GMT

Xpressive是一个C++的正则表辑ּ�库，目前是Boost的候选库�?br>Xpressive和Boost.Regex的区别很大。首先，Xpressive是一个纯头文件的库，也是��_��在��用之前不需要预先编译。其�ơ，Xpressive支持�c�M��于Spirit的静态语义定义�?br>
我们先来看一个例子：

#include <iostream>
#include <boost/xpressive/xpressive.hpp>

using namespace boost::xpressive;

int main()
{
    std::string hello( "hello world!" );

    sregex rex = sregex::compile( "(\\w+) (\\w+)!" );
    smatch what;

    if( regex_match( hello, what, rex ) )
    {
        std::cout << what[0] << '\n'; // whole match
        std::cout << what[1] << '\n'; // first capture
        std::cout << what[2] << '\n'; // second capture
    }

    return 0;
}

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

如果惛_��一个串中查扄��合该文法的子�Ԍ��可以使用regex_search�Q�用法和regex_match一��P��此外�q�可以用regex_replace来进行替换�?br>

静态文法：
Xpressive除了可以用compile来分析一个文法串之外�Q�还可以用类��g��Spirit的方式来静态的指定文法�Q?br>

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

�q�将定义一个表�C�金额的�Ԍ��其中_d表示一个数字，相当于串 $\d+.\d\d
�q�样定义文法��比之前的动态定义更加高效，�q�且�q�有一个附加的好处�Q?br>分��定义�Q?/p>

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

�q�样s表示为用括号括�v来的re
通过分��定义�Q�文法能被表�C�的更加清楚�?br>更加��的是，分��定义�q�可以向后引用，因此能够分析EBNF

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

expression定义了一个四则表辑ּ��Q�注意其中group的定义�?br>�q�里必须使用by_ref是因为Xpressive默认是值拷贝，如果�q�里使用默认的方式，那么会造成一个无限��@环�?br>

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

shifan3 2006-07-27 16:27 发表评论

[yc]乱序Policy手法

shifan3 — Sun, 23 Jul 2006 17:06:00 GMT

看了546@C++@Freecity之后�Q�发觉非常有意�?由此产生一些想�?/p>

很多时候写一个类的时候，需要多个模版参敎ͼ�例如一个遗传算法的��法�c�，需要一个模版参数来指定交配方式�Q�另一个模版参数来指定子代选择的方式，�q�要一个参数来指定变异的方式。那么一般来��_��q�个�c�M��写成�Q?/p>

template        , class CrossPolicy = AvgCrossPolicy                        //杂交方式
        , class SelectPolicy = DefaultSelectPolicy                //子代选择的方�?br>        , class VariationPolicy = ReverseVariationPolicy>        //变异方式
class Gene
        : private AvgCrossPolicy
        , private SelectPolicy
        , private VariationPolicy
{
        ....
};

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

546提供了一�U�有效的�Ҏ��Q�可以让我们仅仅指定变异参数�Q�而不用写出另两个Policy
甚至允许我们以�Q意的��序书写几个Policy参数�Q�都不会有问�?/p>

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

如何在一个TypeList中查找一个类型的子类�Q?br>首先要有一个IsDerivedFrom
�q�个比较��?br>template
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
struct FindChild
{
        template
        struct Select
        {
                typedef typename List::Type Type;
        };

        template <>
        struct Select
        {
                typedef typename FindChild::Type Type;
        };

typedef typename Select >::Type Type;
};

当然�q�要对一些特�D�情况进行特化，例如NullType
template
struct FindChild
{
typedef NullType Type;
};
�q�里使用NullType来表明没扑ֈ�

实际操作�Q?br>首先需要给3个Policy3个基�c�，分别�?br>class AvgCrossPolicyBase{};
class SelectPolicyBase{};
class VariationPolicyBase{};
内容为空��p��了，�q�样也没有虚函数调用的开销

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

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

下面要写一些选择�?用于把合适的�c�d��选择出来�Q�如果没扑ֈ��Q�则要��用默认的�c�d��
template
struct Selector
{
        template
        struct Judge
        {
                typedef RetType Type;
        };

        template<>
        struct Judge
        {
                typedef DefaultType Type;
        };
        typedef typename Judge::Type >::Type Type;
};

好啦�Q�现在整个类的声明可以写�?/p>

template        , class CrossPolicy_ = DefaultPolicy
        , class SelectPolicy_ = DefaultPolicy
        , class VariationPolicy_ = DefaultPolicy     //其后的参数用户不可指�?br>        , class List = TYPELIST_3_N(CrossPolicy_, SelectPolicy_, VariationPolicy_)
        , class CrossPolicy = typename Selector::Type
        , class SelectPolicy = typename Selector::Type
        , class VariationPolicy = typename Selector::Type
        >
class Gene
        : private CrossPolicy
        , private SelectPolicy
        , private VariationPolicy
{

        ....
};

其中�W?-7个参敎ͼ�List�Q�CrossPolicy�Q�SelectPolicy和VariationPolicy�Q�是不由用户指定的，仅仅是�ؓ了�v一个别�?br>�W�一个参数T必须指定�Q�然�?�Q?�Q?�q?个参数就可以��L��的改变顺序了
例如�Q�可以写Gene而不会有��M��问题
如果不想要最后面几个参数的话也行�Q�但是代码就要稍微长一�?br>而且最好在�c�里面进�?个typedef
typedef typename Selector::Type CrossPolicy;
�{�，以便在实现的时候��?/p>

shifan3 2006-07-24 01:06 发表评论

[yc]自己实现Lambda�Q�第二部分）

shifan3 — Sat, 15 Jul 2006 07:32:00 GMT

摘要: 发信�? shifan (家没有豚�?T.T), 杉K��: C++�?nbsp; �? 如何实现Lambda[�W�二部分]发信�? 飘�ؓ水云�?(Thu Jun 8 23:30:20 2006), 转信章节:�?�W�一部分的小�l�九:��?如何减少Lambda代码的冗余和依赖性十:bind的实现十一:实现phoenix 八．中期�ȝ��目前的结果是�q�样�?.. 阅读全文

shifan3 2006-07-15 15:32 发表评论

[yc]自己实现Lambda

shifan3 — Fri, 09 Jun 2006 05:23:00 GMT

摘要: 一�Q?nbsp;什么是Lambda所谓Lambda�Q�简单的说就是快速的��函数生成。在C++中，STL的很多算法都要求使用者提供一个函数对象。例如for_each函数�Q�会要求用户提供一个表�?#8220;行�ؓ”的函数对象。以vector��Z��Q�如果想使用for_each对其中的各元素全部赋��gؓtrue�Q�一般需要这么一个函数对象， c... 阅读全文

shifan3 2006-06-09 13:23 发表评论

shifan3 — Sun, 18 Dec 2005 04:02:00 GMT

    最�q��ؓ了解析SQL语法�Q�怀着试一试的心态去��M��boost的spirit库，因�ؓ该库的文档的��介里写着LL parser framework represents parsers directly as EBNF grammars in inlined C++。看着framework�q�个词自然觉得这个库很牛B�Q�试用了一下果然如此�?br>    所谓EBNF��x��展巴克斯范式�Q�是一�U�描�q�Context-Free Language的文法。在目前常见的非自然语言中，大部分都可以用EBNF表示。例如：
      group  ::='('exp ')'
      factor ::=integer| group
      term   ::=factor(('*'factor)|('/'factor ))*
      exp    ::=term(('+'term)|('-'term ))*
�q�是一个整数表辑ּ�的EBNF。该�D�|��q�用spirit在C++中的实现则是�Q?br>

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

�q�里使用=代替::=, �?gt;>代替�I�格�q�接。�ƈ且由于C++语法所限，EBNF中后�|�的*在spirit中改为前�|��?br>�{�式左边的单词被�U�Cؓ一个rule�Q�等式右边�ؓrule的定义。我们可以看��Z��个group是一个exp加上一�Ҏ��P��一个factor是一个整数或者一个group,一个term是一个或多个factor�?/�q�接�Q�一个exp是一个或多个term�?-�q�接。处于最��端的exp可以据此识别��Z��下表辑ּ�

   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之后�Q�我们就可以�?/font> parse函数对一个串�q�行识别了。例�?br>

parse( " (1 + (2 + (3 + (4 + 5)))) " , exp);

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

parse( " hello world " , * anychar_p, space_p);

2。以rule创徏rule�?br>

rule < phrase_scanner_t > exp;

注意虽然可以用这两个办法屏蔽�I�格�Q�但是这样可能完全改变EBNF文法的语义，��其是在语言本��n需要识别空格的时候。对于这�U�情况，可以不��用第三个参数�Q��ƈ在需要出现空格的地方加上space_p,或�?space_p�?space_p�Q�其�?�?分别表示后面的符可��l�出��C��ơ以上和0�ơ以上。例如一个以�I�格分隔的整数列表可以写成int_p >> *(+space_p >> int_p)
如上使用parse可以识别一个串�Q�但�q�不能做更多的操作，例如��语法里的各个成分提取出来。对于这��L��需求，可以通过actor实现。下面是使用actor的一个简单例�?br>

   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;
   }

注意�?span class=identifier>real_p后面的[]�Q�中括号里面是一个仿函数�Q�函数指针或者函数对象）�Q�该仿函数具有如下调用型�?br>

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

一旦spase发现了匹�?span class=identifier>real_p的子�Ԍ��׃��调用该functor。不同的rule可能会对应不同的调用型别�?/span>
�W�一个型别针对一般规则，first和last��Z��个指向字�W�的�q�代器（一般�ؓchar*�Q?匚w��的子串�ؓ[first, last)
�W�二个型别针�Ҏ��字型规则�Q�如real_p和int_p, 参数val是一个数字类型�?br>�W�三个性别针对单字�W�型规则�Q�如space_p, 参数ch是一个字�W�类型�?br>real_p[push_back_a(v)]中的push_back_a是一个spirit已经定义好的functor�Q�它会将匚w��好的内容依照匚w��到的旉��序调用v的push_back函数加入到v中�?br>
到此spirit的常用功能就都介�l�完了。要详细深入了解可以参考spirit的文档�?br>
最后在题一个注意要炏V��spirit的各�U�EBNF�q�接都是指针�q�接�Q�因此才能在expression被赋值前��在group的定义里面��用。所以在使用EBNF的时候一定要��心不要��局部变量的rule提供�l�全局或者类成员变量使用�Q�例如：

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

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

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

shifan3 2005-12-18 12:02 发表评论

欧美日韩视频一区二区三区,老司机一区二区三区,亚洲国产精品久久久久久女王

[yc]用户态非抢占式线�E�库实现

[yc]垃圾回收�Q�C++资源���理杂谈

[yc]详解link

[yc]伪typeof

[yc]Multi Bit Mask

[yc]VC下typeid实现及内存布局分析

[yc]乱序Policy手法

[yc]自己实现Lambda�Q�第二部分）

[yc]自己实现Lambda

[yc]垃圾回收�Q�C++资源��理杂谈