久久久久久无码Av成人影院,久久无码一区二区三区少妇,欧美一区二区久久精品

��介Boost.Regex

RichardHe — Sun, 20 Jul 2008 02:31:00 GMT

��?sup>1
    �? 则表辑ּ��Q�Regular expression�Q�是一�U�在文本处理中经常用到的模式匚w��的�Ş式，可能许多用户熟悉Unix下的grep,sed,awk�{�工��h��者perl语言�Q�它们都�q�泛地用��C��正则表达式。传�l�的C++用户�q�受限于用POSIX C API's�Q�Portable operateing system interface standard)来操作正则表辑ּ��Q�而regex++已经提供了这些API's�Q�虽然它不一定是使用POSIX C 正则表达式库的最好方法。比如regex++能处理宽字符字符�Ԍ��wide character strings�Q�，或者搜索、替换操作（在某�U�意义上�c�M��于sed或perl�Q�，�q�些在传�l�的C 库中是不能实现的�?br>�c�boost::reg_expression是regex++库中的关键类�Q�它表示“机器可读”的正则表辑ּ��Q�reg_expression 是在string的基��之上构徏的，可以认�ؓ它是一个具有string的功能，外加�q�个正则表达式算法所需要的状态机�?br>像std::basic_string一��P��它提供了两个针对char和wchar_t的特化版本：

namespace boost{
template           class traits = regex_traits,
          class Allocator = std::allocator >
class basic_regex;
typedef basic_regex regex;
typedef basic_regex wregex;
}

要知道regex++库到底有什么用�Q�可以试��x��们要写一个信用卡处理�E�序。信用卡通常�?6位数字组成的 ��L��Q�其中每四位一�l�，用空格或�q�字号隔开。在��这些信用卡��L��存入数据库之前，我们��N��不要��验这些数字是否符合正��格式么�Q��ؓ了匹配�Q何一个数字我�? 可以用正则表辑ּ�[0-9]�Q�数字串的宽度可以用[[:digit:]],当然�q�些是POSIX标准。在regex++和perl中可��化�ؓ\d�Q�注意许多老的库們֐�于硬�~�码到C-locale�Q�因此这不是什么问题）。下面的正则表达式可以检验信用卡��L��的格式�?br>(\d{4}[- ]){3}\d{4}
()标记子表辑ּ��Q�{4}表示重复4�ơ。这仅是一个perl,awk,egrep的正则表辑ּ�的例子。regex++也支持那些sed,grep用到的比较老的“基本”语法�Q�虽然它们很��用刎ͼ�除非你需要重用一些已有的基本正则表达式�?/font>

    现在让我们把�q�个表达式置于C++代码中来��验信用卡��L��的格式：

bool validate_card_format(const std::string s)
{
   static const boost::regex e("(\\d{4}[- ]){3}\\d{4}");
   return regex_match(s, e);
}

    注意我们以前是如何将某些额外的�{义序列（或者翻译成�Q��{义字�W�）��d��到表辑ּ�的：要知道，正则表达式引擎处理�{义字�W�前�Q�该转义字符只能�?C++�~�译器识别一�ơ，因此�Q�在C++代码中嵌入正则表辑ּ�的�{义字�W�必��d��写（写两�ơ）�?br>    �q�要注意��C��的编译器必须支持Koening lookup 2�Q�比如VC6��׃��支持�Q�，否则你需要附加一些boost::prefixes到某些函数引用中�?br>    �? 些熟悉信用卡操作的�h�Q�可能还会想��C��面的那种格式适合于�h的阅读，�q�不表示�|�上信用卡系�l�要求的格式�Q�可能是16�?5个没有间隔符的数字串�Q�。我们需要一�U�简单的转换�Ҏ��Q�我们需�?个字�W�串�Q?个是正则表达式，一个是格式字符�Ԍ��提供一�U�被匚w��的内容的描述�Q�。在regex++中，search�? replace都能完成regex_merge��法�Q�对于信用卡的例子我们给��Z��下面2个算法用于格式�{换：

// match any format with the regular expression:
const boost::regex e("\\A(\\d{3,4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})\\z");
const std::string machine_format("\\1\\2\\3\\4");
const std::string human_format("\\1-\\2-\\3-\\4");

std::string machine_readable_card_number(const std::string s)
{
return regex_merge(s, e, machine_format, boost::match_default | boost::format_sed);
}

std::string human_readable_card_number(const std::string s)
{
return regex_merge(s, e, human_format, boost::match_default | boost::format_sed);
}

�q�儿�Q�我们用正则表达式中的子式把��L��分�ؓ4块，format string 用类似sed的语法把被匹配的内容替换��定格式�?br> 上面的例子中�Q�我们还没有直接操作匚w��l�果�Q�匹配结果包括全体匹配和一些子式的匚w��。当需要正则表辑ּ�的匹配结果时�Q�就需要用到class match_results的实例，下面是常用类型的特化版本�Q?br>
namespace boost{
typedef match_results cmatch;
typedef match_results wcmatch;
typedef match_results smatch;
typedef match_results wsmatch;
}

regex_search和regex_grep��法都��用到match_result�?br> 注意�q�些��法�q�不局限于一般的C-strings,��M��双向�q�代器（bidirectional iterator�Q�类型都能被搜烦�Q�这为无�~�搜索�Q何类型数据提供了可能性�?/font>

对于那些不喜�Ƣ模板（templates�Q�的��可以使用class RegEx,它是�Ҏ��板代码的高层�ơ包装，它�ؓ那些使用不到库的整个功能的�h提供了简单的接口�Q�当然它仅支持窄字符�Q�narrow character�Q�和“扩展”的正则表辑ּ�语法�?br> 对于惛_��容POSIX的�h可以使用POSIXAPI函数�Q�regcomp,regexec,regfree,regerror,�q�些对narrow character和Unicode都适用�?/font>

最后注意，�q�个库现在支持运行时本地化（run-time localization�Q�，它能完全识别POSIX正则表达式语法，包括一些多字符的元素比较和同等�c�d��的高�U�特性，它还能兼容其它一些正则表辑ּ�库包括GNU、BSD4的regex包�?/font>

安装和配�|?/strong>

    首先当你从zip文�g解压本库时必��M��留它的内部结构，如果你没�q�样做，那只好删除你解压的文�Ӟ��重现来一�ơ�?br>    �׃��支持大多数常见的�~�译�?标准�?�q�_��Q�这个库不需要作使用前的配置。如果你��到配置问题�Q�或��x��试你的编译器的配�|�信息，可以参�?配置文档�Q�这和boost的其它所有的库的处理�q�程都一��P��?/font>

    �׃��本库混合了模板代码（头文件中�Q�和静态代码数据（cpp文�g中）�Q�所以在你��用之前，必须��库支持的代�?生成到库内和档案文�g中。以下是几个具体�q�_��的操作步骤：
Borland C++ Builder
�?/font>
Microsoft Visual C++ 6 and 7
如果你��用VC5�Q�你可能要找一下本库的以前版本�?br>打开命��o提示�W�（其MSVC环境变量必须已定义，如果没有可运行Vcvars32.bat�Q�位�?lt;VC6>\bin�Q�，�q�入\libs\regex\build 目录
选择正确的makefile,VC6++的是vc6.mak,支持STLPort的是vc6-stlport.mak
如下调用
nmake -fvc6.mak
如果惛_��VC6子目录包含所有的lib、dll文�g�Q�lib文�g拷在\lib�Q�dll文�g拷在\bin�Q�可使用
nmake -fvc6.mak install
删除生成�q�程中所有的临时文�g�Q�可使用
nmake -fvc6.mak clean

最后只需��d��根目录到你的工程所包含的目录列表中。没有必要手动将*.lib文�g加到工程中，因�ؓ在头文�g会选择正确�?lib文�g�?br>注意�Q�如果想静态地铑օ�regex库，可定义BOOST_REGEX_STATIC_LINK�Q�在release版中生效�Q��?br>      如果想直接��用源文�g�Q�可定义BOOST_REGEX_NO_LIB�Q�这栯��动选择库将失效�?/font>

1.��介出处：http://www.boost.org/libs/regex/doc/introduction.html
2.Koening lookup�Q�When a function is called, in order to determine if that function is visible in the current scope, the namespaces in which the functions parameters reside must be taken into account.

RichardHe 2008-07-20 10:31 发表评论

boost::regex

RichardHe — Sun, 20 Jul 2008 01:45:00 GMT

boost::regex

boost::regex的用�?/li>

        bool validate_card_format(const std::string s)
        {
           static const boost::regex e("(\\d{4}[- ]){3}\\d{4}");
           return regex_match(s, e);
        }

boost::regex的默认正则表辑ּ�语法是perl语法

boost::regex支持perl regular表达式、POSIX-Extended regular表达式和POSIX-Basic Regular表达式，但默认的表达式语法是perl语法�Q�如果要使用其余两种语法需要在构造表辑ּ�的时候明��指定�?/p>

        例如�Q�下面两�U�方法效果相�?br>        // e1 is a case sensitive Perl regular expression:
        // since Perl is the default option there's no need to explicitly specify the syntax used here:
        boost::regex e1(my_expression);
        // e2 a case insensitive Perl regular expression:
        boost::regex e2(my_expression, boost::regex::perl|boost::regex::icase);

perl正则表达式语�?/li>

perl正则表达式语法可参见《perl语言入门》第7�?�?章或boost的文档。这里列出的语法是不全面的，而且部分说明可能�q�不清楚�?/p>

. ��L��字符;使用match_no_dot_null标志时不匚w��NULL字符; 使用match_not_dot_newline时不匚w��换行字符

        ^ 匚w��行的开�?br>        $ 匚w��行的�l�束
        * 重复零次或则更多,例如a*b可匹配b,ab,aab,aaaaaaab
        + 重复一�ơ以上，例如a+b可匹配ab,aab,aaaaaaaab。但不能匚w��b�?br>        ? 零次或则一�ơ，例如ca?b匚w��cb,cab但不匹被caab
        a{n} 匚w��字符'a'重复n��?br>        a{n,}�Q�字�W�a重复n�ơ以上（含n�ơ）
        a{n,m} a重复n到m�ơ（含）

*? 匚w��前一个原子零�ơ以�?br> +? 匚w��前一个原子一�ơ以�?br> ?? 匚w��前一个原子零�ơ以�?br> {n,}? 匚w��前一个原子n�ơ以�?�?
{n,m? 匚w��前一个原子n到m��?�?

        | 或操作，例如ab(d|ef)匚w��abd或则abef
        [] 字符集操作，例如[abc]��匹配�Q何单个字�W?a'�Q?b'�Q?c'
        [a-d]�Q�表�C�a、b、c、d
        ^否操作，例如[^a-c]表示a至c之外的所有字�W?br>

boost::regex对unicode�~�码的支�?/li>

boost::regex使用ICU来实现对unicode及unicode变种的支持，�q�需要在�~�译boost的时候指出是否�� 用ICU以及ICU所在的目录。否则编译出来的boost::regex不支持unicode�~�码。其中boost::wregex支持unicode�~? 码的搜烦�Q�如果要搜烦UTF-8、UTF-16、UFT-32�~�码的字�W�串�Q�则要用boost::u32regex。注意boost::wregex只能支持unicode�~�码�Q�不能支持uft�~�码�?/p>

搜烦时如何忽略大��写

如果要在搜烦时忽略大��写�Q�即大小写不敏感�Q�，则要用到表达式选项boost::regex::icase�Q�例如： boost::regex e2(my_expression, boost::regex::perl|boost::regex::icase);

RichardHe 2008-07-20 09:45 发表评论

RichardHe — Wed, 16 Jul 2008 10:10:00 GMT

关于## �?#�?@的用�?br>

## 是连接符�?�q�接两个�?##被称��接符�Q�concatenator�Q�，用来��两个Token�q�接��Z��个Token。注意这里连接的对象是Token��p��Q�而不一定是宏的�?
量。比如你要做一个菜单项命��o名和函数指针�l�成的结构体的数�l�，�q�且希望在函数名和菜单项命��o名之间有直观的、名字上的关�p�R��那��可以��用：宏参�?#
固定部分。当然还可以n�?#�W�号�q�接 n+1个Token�Q�这个特性也�?�W�号所不具备的�?
#define LINK_MULTIPLE(a,b,c,d) a##_##b##_##c##_##d
typedef struct _record_type LINK_MULTIPLE(name,company,position,salary);
// �q�里�q�个语句��展开为：
//      typedef struct _record_type name_company_position_salary;

#@功能是将其后面的宏参数进行字�W�化�?br>#define makechar(x) #@x
a = makechar(b);
//a = 'b';

#是把名字代替成字�W�串,宏体中，#的功能是��其后面的宏参数�q�行字符串化操作�Q�Stringfication�Q�，��单说��是在对它所引用的宏变量通过替换后在其左叛_��加上一�?
双引受��?br>#define WARN_IF(EXP)        \
        do{ if (EXP)        \
                fprintf(stderr, "Warning: " #EXP "\n"); }       \
        while(0)
那么实际使用中会出现下面所�C�的替换�q�程�Q?
WARN_IF (divider == 0);
被替换�ؓ
do {
        if (divider == 0)
fprintf(stderr, "Warning" "divider == 0" "\n");
} while(0);
�q�样每次divider�Q�除敎ͼ��?的时候便会在标准错误��上输出一个提�C�Z��息�?

!IF constantexpression

如果 constantexpression 计算�l�果为非零��|��则处�?!IF 和下一�?!ELSE �?!ENDIF 之间的语句�?br>!ENDIF

标记 !IF�?strong>!IFDEF �?!IFNDEF 块的�l�尾。同一行上 !ENDIF 后面的所有文本被忽略�?/p>

RichardHe 2008-07-16 18:10 发表评论

extern "C"

RichardHe — Thu, 10 Jul 2008 09:27:00 GMT

前些天，�~�程序是用到了很久以前写的C�E�序�Q�想把里面的函数利用��h��Q�连接发现出��C��找不到具体函数的错误�Q?/p>

以下是假设旧的C�E�序�?/p>

C的头文�g

/*-----------c.h--------------*/
#ifndef _C_H_
#define _C_H_
extern int add(int x, int y);
#endif

C的源文�g

/*-----------c.c--------------*/
int add(int x, int y){
	return x+y;
}

C++的调�?/p>

/*-----------cpp.cpp--------------*/
#include "c.h"
void main()
{
	add(1, 0);
}

�q�样�~�译会��生错误cpp.obj : error LNK2001: unresolved external symbol "int __cdecl add(int,int)" (?add@@YAHHH@Z)�Q�原因是找不到add的目标模�?/p>

�q�才令我惌��vC++重蝲的函数命名方式和C函数的命名方式，让我们回��一下：C中函数编译后命名会在函数名前加以"_",比如add函数�~�译成obj文�g时的实际命名为_add�Q�而c++命名则不同，��Z��实现函数重蝲同样的函数名add因参数的不同会被�~�译成不同的名字

例如

int add(int , int)==>add@@YAHHH@Z,

float add(float , float )==>add@@YAMMM@Z,

以上是VC6的命名方式，不同的编译器会不同，��M��不同的参数同��L��函数名将�~�译成不同目标名�Q�以便于函数重蝲是调用具体的函数�?/p>

�~�译cpp.cpp中编译器在cpp文�g中发现add(1, 0);的调用而函数声明�ؓextern int add(int x, int y);�~�译器就军_��L��add@@YAHHH@Z�Q�可惜他找不刎ͼ�因�ؓC的源文�g�?font color="#990000">extern int add(int x, int y);�~�译成_add了；

��Z��解决�q�个问题C++采用了extern "C",�q�就是我们的主题�Q�想要利用以前的C�E�序库，那么你就要学会它�Q�我们可以看以下标准头文件你会发玎ͼ�很多头文仉��有以下的�l�构

#ifndef __H
#define __H
#ifdef __cplusplus
extern "C" {
#endif

extern int f1(int, int);
extern int f2(int, int);
extern int f3(int, int);

	
#ifdef __cplusplus
}
#endif

#endif /*__H*/

如果我们仿制该头文�g可以得到

#ifndef _C_H_
#define _C_H_
#ifdef __cplusplus
extern "C" {
#endif

extern int add(int, int);

#ifdef __cplusplus
}
#endif

#endif /* _C_H_ */

�q�样�~�译

/*-----------c.c--------------*/
int add(int x, int y){
return x+y;
}

�q�时源文件�ؓ*.c�Q?/font>__cplusplus没有被定义，extern "C" {}�q�时没有生效对于C他看到只�?font color="#990000">extern int add(int, int);
add函数�~�译成_add(int, int);

而编译c++源文�?/font>

/*-----------cpp.cpp--------------*/
#include "c.h"
void main()
{
add(1, 0);
}
�q�时源文件�ؓ*.cpp,__cplusplus被定�?对于C++他看到的�?font color="#990000">extern "C" {extern int add(int, int);}�~�译器就会知�?add(1, 0);调用的C风格的函敎ͼ��׃��知道去c.obj中找_add(int, int)而不�?/strong>add@@YAHHH@Z�Q?/font>

�q�也��׃ؓ什么DLL中常看见extern "C" {}�Q?/strong>windows是采用C语言�~�制他首先要考虑到C可以正确调用�q�些DLL�Q�而用户可能会使用C++�?font color="#990000">extern "C" {}��׃��发生作用

RichardHe 2008-07-10 17:27 发表评论

推荐--丰富的游戏开发的站点

RichardHe — Wed, 09 Jul 2008 07:11:00 GMT
按自已认为的站点内容的好坏排了个序的�Q?br>
http://www.gameres.com     属于游戏人的中文�|�络�q�_��
http://www.chinagamedev.net    中国游戏开发�?br> http://www.gamedevelop.net    中国游戏开发技术资讯网 http://www.ogdev.net     中国�|�游研发中心
http://www.chaosstars.com    中国游戏开发基�?br> http://gamedev.91.com    游戏制作联盟
http://www.chinadv.com    中国数码视频在线
http://www.u9u6.com     u9u6游戏�|?br> http://www.amanpage.com    游戏开发站�?br> http://www.gamecollege.org    游戏学院

手机随便列的�Q?br> http://soft.yesky.com/SoftChannel/72348977504190464/20031215/1753502.shtml Java   手机游戏开发专�?br>
国外站点�Q?br> http://www.gdse.com    Game Development Search Engine
http://www.gamedev.net
http://www.igda.org    International Game Developers Association
http://www.gameinstitute.com   Game Institute
http://www.gametutorials.com   Game Tutorials
http://www.sagamedev.co.za    South African Game Development
http://lgdc.sunsite.dk    Linux Game Development Center

个�h的及专题的：
http://gd.91.com/zt/ogre/index.asp      OGRE引擎研究�?br> http://www.gameres.com/Topics/Technic/OGRE      OGRE引擎教程

RichardHe 2008-07-09 15:11 发表评论

用Boost.Spirit写了一个term下c++词法高亮

RichardHe — Tue, 08 Jul 2008 03:49:00 GMT
��http://hi.baidu.com/yesbaba/blog/item/79c3eb13215da0d2f7039ec9.html

1.1版，命��o行下使用�?.0版，

    增加更易用的�Ҏ��Q�点击coco.exe�Q�将文�g拖入�H�口�Q�高亮文件输出到同名txt文�g�?/font>

    转成html的功能以后不懒的时候再写吧

1.0版：命��o行下使用�Q�输出到stdout�Q?/font>

可以重定向到文�g�Q�彩色复制就行了
coco.exe xxx.cpp > whateverfile
��C��本打开whateverfile�Q�复�Ӟ��在bbs上彩色粘�?br> �~�译�q�个大概需�?癑֤�M内存

想直接现在用的，可以在这下蝲�Q�这是水木的附�g�Q�不知道能有效到什么时�?/font>

http://www.newsmth.net/att.php?p.335.193566.17417.exe

论坛可以用它来实��C��码高亮显�C?br> 以后再改�q?/font>

正确的代码coco应该不会分析错，能分析正��的不一定是正确的代�?/font>

��M��码可以先看spirit最基础的ch_p,str_p�{�，�q�有spirit文档中的utility

再看如何分析文�g

http://hi.baidu.com/yesbaba/blog/item/091ca995d0fe6e49d1135e8b.html

gnu source highlight��可以实现这个功能了�Q�我做这个一来是学spirit�l�练手，

二来是要做个评��设计�Q�三来这个很实用�Q��^常在水木帖代码也能用的上

///////////////////////////////////////////////////////////////////////////////
//
//       highlight c++ source code in ansi code format
//       COCO (COlorful COde) version 1.1
//       ibe@newsmth.net
//       [ 2007-08-13 ]
//
///////////////////////////////////////////////////////////////////////////////

#include
#include
#include
#include
#include
#include
///////////////////////////////////////////////////////////////////////////////
using namespace boost::spirit;
using namespace std;

////////////////////////////////////////////////////////////////////////////
//
//       Types
//types needed for file parsing
////////////////////////////////////////////////////////////////////////////
typedef char char_t;
typedef file_iterator < char_t > iterator_t;
typedef scanner < iterator_t > scanner_t;
typedef rule < scanner_t > rule_t;

////////////////////////////////////////////////////////////////////////////
//To ansi�Q�action函数�Q�匹配后输出成ansi代码的彩色控制符�Q?/font>
//可参考各大高校bbs的asciiart版精华区�Q�可以输出成需要的格式�Q�如html
//
////////////////////////////////////////////////////////////////////////////
ofstream outfile;
namespace to_ansi
{
  void
   black (iterator_t first, iterator_t const &last)
   {
     outfile << "\033[1;30m";
    while (first != last)
       outfile << *first++;
     outfile << "\033[m";
   }

  void
   red (iterator_t first, iterator_t const &last)
   {
     outfile << "\033[1;31m";
    while (first != last)
       outfile << *first++;
     outfile << "\033[m";
   }

  void
   green (iterator_t first, iterator_t const &last)
   {
     outfile << "\033[1;32m";
    while (first != last)
       outfile << *first++;
     outfile << "\033[m";
   }

  void
   yellow (iterator_t first, iterator_t const &last)
   {
     outfile << "\033[1;33m";
    while (first != last)
       outfile << *first++;
     outfile << "\033[m";
   }

  void
   blue (iterator_t first, iterator_t const &last)
   {
     outfile << "\033[1;34m";
    while (first != last)
       outfile << *first++;
     outfile << "\033[m";
   }

  void
   magenta (iterator_t first, iterator_t const &last)
   {
     outfile << "\033[1;35m";
    while (first != last)
       outfile << *first++;
     outfile << "\033[m";
   }

  void
   cyan (iterator_t first, iterator_t const &last)
   {
     outfile << "\033[1;36m";
    while (first != last)
       outfile << *first++;
     outfile << "\033[m";
   }

  void
   white (iterator_t first, iterator_t const &last)
   {
     outfile << "\033[1;37m";
    while (first != last)
       outfile << *first++;
     outfile << "\033[m";
   }

  void
   echo (iterator_t first, iterator_t const &last)
   {
    while (first != last)
       outfile << *first++;
   }
}
////////////////////////////////////////////////////////////////////////////
//
//       cpp lex
//c++的词法描�q�ͼ�有了comment_p��方便多了，识别函数名还没实�?/font>
////////////////////////////////////////////////////////////////////////////
namespace cpp_lex
{
     rule_t comment = comment_p ("/*", "*/")
                     | comment_p ("http://")
                     ;
     rule_t whitespace = space_p
                     ;
     rule_t include = str_p ("#include") >> *space_p >>
                     (comment_p ("<", ">") | comment_p ("\"", "\""))
                     ;
     rule_t preprocessor = (include | "##" | "#define" | "#error" | ("#if" >> space_p)
                         | "#ifdef" | "#ifndef" | "#else" | "#elif"
                         | "#endif" | "#line" | "#pragma" | "#undef" | "#"
                         | "__LINE__" | "__FILE__" | "__DATE__" | "__TIME__"
                         | "_cplusplus" | "__STDC__")
                         >> space_p
                         ;
     rule_t keyword_ = str_p ("asm") | "auto" | "bool" | "break" | "case"
                     | "catch" | "char" | "class" | "const" | "const_cast"
                     | "continue" | "default" | "delete" | "do" | "double"
                     | "dynamic_cast" | "else" | "enum" | "explicit"
                     | "extern" | "false" | "float" | "for" | "friend"
                     | "goto" | "if" | "inline" | "int" | "long" | "mutable"
                     | "namespace" | "new" | "operator" | "private"
                     | "protected" | "public" | "register" | "reinterpret_cast"
                     | "return" | "short" | "signed" | "sizeof" | "static"
                     | "static_cast" | "struct" | "switch" | "template"
                     | "this" | "throw" | "true" | "try" | "typedef" | "typeid"
                     | "typename" | "union" | "unsighed" | "using" | "virtual"
                     | "void" | "volatile" | "wchar_t" | "while"
                     ;
     rule_t keyword = keyword_ >> space_p
                     ;
     rule_t identifer = (alpha_p | '_') >> *(alnum_p | '_')
                     ;
         rule_t operators = punct_p - '`' - '@' - '$' - '\\'
                         ;
     rule_t number = real_p
                     ;
     rule_t str = confix_p ("\"", *c_escape_ch_p, "\"")
                     ;
     rule_t charcter = confix_p("\'", *c_escape_ch_p, "\'")
                     ;
     rule_t constant = number
                     | str
                     | charcter
                     ;

};

////////////////////////////////////////////////////////////////////////////
//
//       Main program
//
////////////////////////////////////////////////////////////////////////////
int
main (int argc, char *argv[])
{
         string filepath;
        if (2 > argc)
         {//把要处理的文件拖到窗口内
                 cout << "drag file to this windows\n";
                 string filepath_input;
                 getline(cin, filepath_input);
                 filepath_input.erase(filepath_input.end()-1); //��L��l�尾�?\"'
                 filepath_input.erase(filepath_input.begin());   //��L��开�?
                for (int i = 0; filepath_input[i] != 0; i++) {
                         filepath.push_back(filepath_input[i]);
                        if (filepath_input[i] == '\\')
                                 filepath.push_back('\\');
                 }
         }else{
                // for console usage
                 filepath = argv[1];
         }
         iterator_t first (filepath);
        if (!first)   {
                 std::cerr << "Unable to open file!\n";
                return -1;
         }

        // Create an EOF iterator
         iterator_t last = first.make_end ();

         string filepath_output = filepath+".txt";
         outfile.open(filepath_output.c_str());
        // A simple rule词法对应的颜色在�q�里改就可以
         rule_t r = *(
                 cpp_lex::comment[&to_ansi::cyan]
                 | cpp_lex::constant[&to_ansi::yellow]
                 | cpp_lex::preprocessor[&to_ansi::red]
                 | cpp_lex::keyword[&to_ansi::green]
                 | cpp_lex::whitespace[&to_ansi::echo]
                 | cpp_lex::operators[&to_ansi::magenta]
                 | cpp_lex::identifer[&to_ansi::white]
                 )
                 ;
        //
        // Parse
        /*The parse_info structure
         The functions above return a parse_info structure parameterized by the iterator type passed in.
         The parse_info struct has these members:parse_info
         stop     Points to the final parse position (i.e The parser recognized and processed the input up to this point)
         hit     True if parsing is successful. This may be full: the parser consumed all the input, or partial: the parser consumed only a portion of the input.
         full     True when we have a full match (i.e The parser consumed all the input).
         length     The number of characters consumed by the parser. This is valid only if we have a successful match (either partial or full).
        */
         parse_info < iterator_t > info = parse (first, last, r);

        // This really shouldn't fail...
        if (info.full)
                 std::cout << "\nParse succeeded!\n";
        else
                 std::cout << "\nParse failed!\n";

        std::cout << "highlight file saved in " << filepath_output << endl;
         string end;
         getline (cin, end);//按回车键推出�H�口

        return 0;
}

�q�只是个词法高亮�E�序�Q�还不能识别语法�Q�如函数�{�，用正则也能做�Q�但boost.spirit更简�?/font>

RichardHe 2008-07-08 11:49 发表评论

内存分区

RichardHe — Sat, 05 Jul 2008 05:39:00 GMT
来自http://www.shnenglu.com/road420/archive/2008/07/05/55388.html

五大内存分区
    在C++中，内存分成5个区�Q�他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区�?br>    栈，��是那些��q��译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等�?br>    堆，��是那些由new分配的内存块�Q�他们的释放�~�译器不�ȝ��Q�由我们的应用程序去控制�Q�一般一个new��p��对应一个delete。如果程序员没有释放掉，那么在程序结束后�Q�操作系�l�会自动回收�?br>    自由存储区，��是那些由malloc�{�分配的内存块，他和堆是十分�怼�的，不过它是用free来结束自��q��生命的�?br>    全局/静态存储区�Q�全局变量和静态变量被分配到同一块内存中�Q�在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有�q�个区分了，他们共同占用同一块内存区�?br>    帔R��存储区，�q�是一块比较特�D�的存储区，他们里面存放的是帔R��Q�不允许修改�Q�当�Ӟ��你要通过非正当手�D�也可以修改�Q�而且�Ҏ��很多�Q?br>明确区分堆与�?br>    在bbs上，堆与栈的区分问题�Q�似乎是一个永恒的话题�Q�由此可见，初学者对此往往是�؜淆不清的�Q�所以我军_��拿他�W�一个开刀�?br>    首先�Q�我们�D一个例子：
    void f() { int* p=new int[5]; }
    �q�条短短的一句话��包含了堆与栈，看到new�Q�我们首先就应该惛_��Q�我们分配了一块堆内存�Q�那么指针p呢？他分配的是一块栈内存�Q�所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在�E�序会先��定在堆中分配内存的大小�Q�然后调用operator new分配内存�Q�然后返回这块内存的首地址�Q�放入栈中，他在VC6下的汇编代码如下�Q?br>    00401028   push        14h
    0040102A   call        operator new (00401060)
    0040102F   add         esp,4
    00401032   mov         dword ptr [ebp-8],eax
    00401035   mov         eax,dword ptr [ebp-8]
    00401038   mov         dword ptr [ebp-4],eax
    �q�里�Q�我们�ؓ了简单�ƈ没有释放内存�Q�那么该怎么去释攑֑��Q�是delete p么？澻I��错了�Q�应该是delete []p�Q�这是�ؓ了告诉编译器�Q�我删除的是一个数�l�，VC6��׃��Ҏ��相应的Cookie信息去进行释攑ֆ�存的工作�?br>    好了�Q�我们回到我们的主题�Q�堆和栈�I�竟有什么区别？
    主要的区别由以下几点�Q?br>    1、管理方式不同；
    2、空间大��不同；
    3、能否��生碎片不同；
    4、生长方向不同；
    5、分配方式不同；
    6、分配效率不同；
    ��理方式�Q�对于栈来讲�Q�是��q��译器自动��理�Q�无需我们手工控制�Q�对于堆来说�Q�释攑ַ�作由�E�序员控�Ӟ��Ҏ��产生memory leak�?br>    �I�间大小�Q�一般来讲在32位系�l�下�Q�堆内存可以辑ֈ�4G的空��_��从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲�Q�一般都是有一定的�I�间大小的，例如�Q�在VC6下面�Q�默认的栈空间大��是1M�Q�好像是�Q�记不清楚了�Q�。当�Ӟ��我们可以修改�Q?nbsp;
    打开工程�Q�依�ơ操作菜单如下：Project->Setting->Link�Q�在Category 中选中Output�Q�然后在Reserve中设定堆栈的最大值和commit�?br>注意�Q�reserve最��gؓ4Byte�Q�commit是保留在虚拟内存的页文�g里面�Q�它讄��的较大会使栈开辟较大的��|��可能增加内存的开销和启动时间�?br>    ��片问题�Q�对于堆来讲�Q�频�J�的new/delete势必会造成内存�I�间的不�q�箋�Q�从而造成大量的碎片，使程序效率降低。对于栈来讲�Q�则不会存在�q�个问题�Q? 因�ؓ栈是先进后出的队列，他们是如此的一一对应�Q�以至于永远都不可能有一个内存块从栈中间弹出�Q�在他弹��Z��前，在他上面的后�q�的栈内容已�l�被弹出�Q�详�l�的可以参考数据结构，�q�里我们��׃��再一一讨论了�?br>    生长方向�Q�对于堆来讲�Q�生长方向是向上的，也就是向着内存地址增加的方向；对于栈来�Ԍ��它的生长方向是向下的�Q�是向着内存地址减小的方向增�ѝ�?br>    分配方式�Q�堆都是动态分配的�Q�没有静态分配的堆。栈�?�U�分配方式：静态分配和动态分配。静态分配是�~�译器完成的�Q�比如局部变量的分配。动态分配由alloca函数�q�行分配�Q�但是栈的动态分配和堆是不同的，他的动态分配是��q��译器�q�行释放�Q�无需我们手工实现�?br>    分配效率�Q�栈是机器系�l�提供的数据�l�构�Q�计��机会在底层�Ҏ��提供支持�Q�分配专门的寄存器存放栈的地址�Q�压栈出栈都有专门的指��o执行�Q�这��决定了栈的效率�? 较高。堆则是C/C++函数库提供的�Q�它的机制是很复杂的�Q�例如�ؓ了分配一块内存，库函��C��按照一定的��法�Q�具体的��法可以参考数据结�?操作�pȝ��Q�在�? 内存中搜索可用的��_��大小的空��_��如果没有��_��大小的空��_��可能是由于内存碎片太多）�Q�就有可能调用系�l�功能去增加�E�序数据�D늚�内存�I�间�Q�这样就有机会分到��够大��的内存�Q�然后进行返回。显�Ӟ��堆的效率比栈要低得多�?br>    从这里我们可以看刎ͼ�堆和栈相比，�׃��大量new/delete的��用，�Ҏ��造成大量的内存碎片；�׃��没有专门的系�l�支持，效率很低�Q�由于可能引发用��h�? 和核心态的切换�Q�内存的甌��Q�代价变得更加昂��c��所以栈在程序中是应用最�q�泛的，��q��是函数的调用也利用栈��d��成，函数调用�q�程中的参数�Q�返回地址�Q�EBP和局部变量都采用栈的方式存放。所以，我们推荐大家��量用栈�Q�而不是用堆�?br>    虽然栈有如此众多的好处，但是�׃��和堆相比不是那么灉|��Q�有时候分配大量的内存�I�间�Q�还是用堆好一些�?br>    无论是堆�q�是栈，都要防止��界现象的发生（除非你是故意使其��界�Q�，因�ؓ��界的结果要么是�E�序崩溃�Q�要么是摧毁�E�序的堆、栈�l�构�Q��生以想不到的�l�果,��? ��是在你的程序运行过�E�中�Q�没有发生上面的问题�Q�你�q�是要小心，说不定什么时候就崩掉�Q�那时候debug可是相当困难的：�Q?br>    对了�Q�还有一件事�Q�如果有人把堆栈合�v来说�Q�那它的意思是栈，可不是堆�Q�呵呵，清楚了？
static用来控制变量的存储方式和可见�?br>       函数内部定义的变量，在程序执行到它的定义处时�Q�编译器为它在栈上分配空��_��函数在栈上分配的�I�间在此函数执行�l�束时会释放掉，�q�样��׃�生了一个问�? 如果惛_��函数中此变量的��g��存至下一�ơ调用时�Q�如何实玎ͼ� 最�Ҏ��惛_��的方法是定义一个全局的变量，但定义�ؓ一个全局变量有许多缺点，最明显的缺�Ҏ��破坏了此变量的访问范��_��使得在此函数中定义的变量�Q�不仅仅受此函数控制�Q��?/p>
       需要一个数据对象�ؓ整个�c�而非某个对象服务,同时又力求不破坏�cȝ��装�?卌��求此成员隐藏在类的内部，对外不可见�?/p>
       static的内部机�Ӟ��
       静态数据成员要在程序一开始运行时��必��d��在。因为函数在�E�序�q�行中被调用�Q�所以静态数据成员不能在��M��函数内分配空间和初始化�?br>       �q�样�Q�它的空间分配有三个可能的地方，一是作为类的外部接口的头文�Ӟ��那里有类声明�Q�二是类定义的内部实玎ͼ�那里有类的成员函数定义；三是应用�E�序的main�Q�）函数前的全局数据声明和定义处�?br>      静态数据成员要实际地分配空��_��故不能在�cȝ��声明中定义（只能声明数据成员�Q�。类声明只声明一个类�?#8220;��寸和规�?#8221;�Q��ƈ不进行实际的内存分配�Q�所以在�c�d�� 明中写成定义是错误的。它也不能在头文件中�c�d��明的外部定义�Q�因为那会造成在多个��用该�cȝ��源文件中�Q�对光��复定义�?br>      static被引入以告知�~�译器，��变量存储在�E�序的静态存储区而非栈上�I�间�Q�静�?br>数据成员按定义出现的先后��序依次初始化，注意静态成员嵌套时�Q�要保证所嵌套的成员已�l�初始化了。消除时的顺序是初始化的反顺序�?/p>
       static的优势：
       可以节省内存�Q�因为它是所有对象所公有的，因此�Q�对多个对象来说�Q�静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一��P��但它�? 值是可以更新的。只要对静态数据成员的值更��C��ơ，保证所有对象存取更新后的相同的��|��q�样可以提高旉��效率�?/p>
        引用静态数据成员时�Q�采用如下格式：
         <�c�d��>::<静态成员名>
    如果静态数据成员的讉K��权限允许的话(即public的成�?�Q�可在程序中�Q�按上述格式
来引用静态数据成员�?/p>
       PS:
      (1)�cȝ��静态成员函数是属于整个�c�而非�cȝ��对象�Q�所以它没有this指针�Q�这��导�?br>了它仅能讉K��cȝ��静态数据和静态成员函数�?br>      (2)不能��静态成员函数定义�ؓ虚函数�?br>      (3)�׃��静态成员声明于�c�M��Q�操作于其外�Q�所以对其取地址操作�Q�就多少有些�Ҏ��
�Q�变量地址是指向其数据�c�d��的指�?�Q�函数地址�c�d��是一�?#8220;nonmember函数指针”�?/p>       (4)�׃��静态成员函数没有this指针�Q�所以就差不多等同于nonmember函数�Q�结果就
产生了一个意想不到的好处�Q�成��Z��个callback函数�Q��得我们得以将C++和C-based X W
indow�pȝ��l�合�Q�同时也成功的应用于�U�程函数�w�上�?br>      (5)static�q�没有增加程序的时空开销�Q�相反她�q�羃短了子类对父�c�静态成员的讉K��
旉��Q�节省了子类的内存空间�?br>      (6)静态数据成员在<定义或说�?gt;时前面加关键字static�?br>      (7)静态数据成员是静态存储的�Q�所以必��d��它进行初始化�?br>      (8)静态成员初始化与一般数据成员初始化不同:
      初始化在�c�M��外进行，而前面不加static�Q�以免与一般静态变量或对象相�؜淆；
      初始化时不加该成员的讉K��权限控制�W�private�Q�public�{�；
           初始化时使用作用域运��符来标明它所属类�Q?br>           所以我们得出静态数据成员初始化的格式：
         <数据�c�d��><�c�d��>::<静态数据成员名>=<�?gt;
      (9)��Z��防止父类的媄响，可以在子�c�d��义一个与父类相同的静态变量，以屏蔽父�cȝ��影响。这里有一炚w��要注意：我们说静态成员�ؓ父类和子�c�d��享，但我们有重复定义了静态成员，�q�会不会引�v错误呢？不会�Q�我们的�~�译器采用了一�U�绝妙的手法�Q�name-mangling 用以生成唯一的标志�?br>

RichardHe 2008-07-05 13:39 发表评论

回调函数

RichardHe — Sat, 05 Jul 2008 05:39:00 GMT
来自http://www.shnenglu.com/road420/archive/2008/07/05/55390.html

��?br>
　　对于很多初学者来��_��往往觉得回调函数很神�U�，很想知道回调函数的工作原理。本文将要解释什么是回调函数、它们有什么好处、�ؓ什么要使用它们�{�等问题�Q�在开始之前，假设你已�l�熟知了函数指针�?

　　什么是回调函数�Q?/strong>

　　��而言之，回调函数��是一个通过函数指针调用的函数。如果你把函数的指针�Q�地址�Q�作为参��C��递给另一个函敎ͼ�当这个指针被用�ؓ调用它所指向的函数时�Q�我们就说这是回调函数�?br>
　　��Z��么要使用回调函数�Q?/strong>

　　因�ؓ可以把调用者与被调用者分开。调用者不兛_��谁是被调用者，所有它需知道的，只是存在一个具有某�U�特定原型、某些限制条�Ӟ��如返回��gؓint�Q�的被调用函数�?br>
如果想知道回调函数在实际中有什么作用，先假设有�q�样一�U�情况，我们要编写一个库�Q�它提供了某些排序算法的实现�Q�如冒��排序、快速排序、shell�? 序、shake排序�{�等�Q�但��Z��库更加通用�Q�不惛_��函数中嵌入排序逻辑�Q�而让使用者来实现相应的逻辑�Q�或者，惌��库可用于多种数据�c�d��Q�int�? float、string�Q�，此时�Q�该怎么办呢�Q�可以��用函数指针，�q�进行回调�?br>
　　回调可用于通知机制�Q�例如，有时要在�E�序中设�|�一�? 计时器，每到一定时��_��E�序会得到相应的通知�Q�但通知机制的实现者对我们的程序一无所知。而此�Ӟ��需有一个特定原型的函数指针�Q�用�q�个指针来进行回调，来通知我们的程序事件已�l�发生。实际上�Q�SetTimer() API使用了一个回调函数来通知计时器，而且�Q�万一没有提供回调函数�Q�它�q�会把一个消息发往�E�序的消息队列�?br>
　　另一个��用回调机制的 API函数是EnumWindow()�Q�它枚�D屏幕上所有的��层�H�口�Q��ؓ每个�H�口调用一个程序提供的函数�Q��ƈ传递窗口的处理�E�序。如果被调用者返回一�? ��|��q��l�进行�P代，否则�Q�退出。EnumWindow()�q�不兛_��被调用者在何处�Q�也不关心被调用者用它传递的处理�E�序做了什么，它只兛_��q�回��|��因�ؓ ��Z��q�回��|��它将�l�箋执行或退出�?br>
　　不管怎么��_��回调函数是��l�自C语言的，因而，在C++中，应只在与C代码建立接口�Q�或与已有的回调接口打交道时�Q�才使用回调函数。除了上�q�情况，在C++中应使用虚拟�Ҏ��或函数符�Q�functor�Q�，而不是回调函数�?br>
　　一个简单的回调函数实现

下面创徏了一个sort.dll的动态链接库�Q�它导出了一个名为CompareFunction的类�?-typedef int (__stdcall *CompareFunction)(const byte*, const byte*)�Q�它��是回调函数的类型。另外，它也导出了两个方法：Bubblesort()和Quicksort()�Q�这两个�Ҏ��原型相同�Q�但实现了不�? 的排序算法�?br>

void DLLDIR __stdcall Bubblesort(byte* array,int size,int elem_size,CompareFunction cmpFunc);

void DLLDIR __stdcall Quicksort(byte* array,int size,int elem_size,CompareFunction cmpFunc);

　　�q�两个函数接受以下参敎ͼ�

　　·byte * array�Q�指向元素数�l�的指针�Q��Q意类型）�?br>
　　·int size�Q�数�l�中元素的个数�?br>
　　·int elem_size�Q�数�l�中一个元素的大小�Q�以字节为单位�?br>
　　·CompareFunction cmpFunc�Q�带有上�q�原型的指向回调函数的指针�?br>
�q�两个函数的会对数组�q�行某种排序�Q�但每次都需军_��两个元素哪个排在前面�Q�而函��C��有一个回调函敎ͼ�其地址是作��Z��个参��C��递进来的。对�~�写者来��_��? 必介意函数在何处实现�Q�或它怎样被实现的�Q�所需在意的只是两个用于比较的元素的地址�Q��ƈ�q�回以下的某个��|��库的�~�写者和使用者都必须遵守�q�个�U�定�Q�：

　　·-1�Q�如果第一个元素较��，那它在已排序好的数组中，应该排在�W�二个元素前面�?br>
　　·0�Q�如果两个元素相�{�，那么它们的相对位�|��ƈ不重要，在已排序好的数组中，谁在前面都无所谓�?

　　·1�Q�如果第一个元素较大，那在已排序好的数�l�中�Q�它应该排第二个元素后面�?br>
　　��Z��以上�U�定�Q�函数Bubblesort()的实现如下，Quicksort()��q��微复杂一点：

void DLLDIR __stdcall Bubblesort(byte* array,int size,int elem_size,CompareFunction cmpFunc)
{
　for(int i=0; i < size; i++)
　{
　　for(int j=0; j < size-1; j++)
　　{
　　　//回调比较函数
　　　if(1 == (*cmpFunc)(array+j*elem_size,array+(j+1)*elem_size))
　　　{
　　　　//两个相比较的元素�怺��?br>　　　　byte* temp = new byte[elem_size];
　　　　memcpy(temp, array+j*elem_size, elem_size);
　　　　memcpy(array+j*elem_size,array+(j+1)*elem_size,elem_size);
　　　　memcpy(array+(j+1)*elem_size, temp, elem_size);
　　　　delete [] temp;
　　　}
　　}
　}
}

　　注意�Q�因为实��C��使用了memcpy()�Q�所以函数在使用的数据类型方面，会有所局限�?br>
　　对��用者来��_��必须有一个回调函敎ͼ�其地址要传递给Bubblesort()函数。下面有二个��单的�C�Z��Q�一个比较两个整敎ͼ�而另一个比较两个字�W�串�Q?br>

int __stdcall CompareInts(const byte* velem1, const byte* velem2)
{
　int elem1 = *(int*)velem1;
　int elem2 = *(int*)velem2;

　if(elem1 < elem2)
　　return -1;
　if(elem1 > elem2)
　　return 1;

　return 0;
}

int __stdcall CompareStrings(const byte* velem1, const byte* velem2)
{
　const char* elem1 = (char*)velem1;
　const char* elem2 = (char*)velem2;
　return strcmp(elem1, elem2);
}

　　下面另有一个程序，用于��试以上所有的代码�Q�它传递了一个有5个元素的数组�l�Bubblesort()和Quicksort()�Q�同时还传递了一个指向回调函数的指针�?br>

int main(int argc, char* argv[])
{
　int i;
　int array[] = {5432, 4321, 3210, 2109, 1098};

　cout << "Before sorting ints with Bubblesort\n";
　for(i=0; i < 5; i++)
　　cout << array[i] << '\n';

　Bubblesort((byte*)array, 5, sizeof(array[0]), &CompareInts);

　cout << "After the sorting\n";
　for(i=0; i < 5; i++)
　　cout << array[i] << '\n';

　const char str[5][10] = {"estella","danielle","crissy","bo","angie"};

　cout << "Before sorting strings with Quicksort\n";
　for(i=0; i < 5; i++)
　　cout << str[i] << '\n';

　Quicksort((byte*)str, 5, 10, &CompareStrings);

　cout << "After the sorting\n";
　for(i=0; i < 5; i++)
　　cout << str[i] << '\n';

　return 0;
}

　　如果惌��行降序排序（大元素在先）�Q�就只需修改回调函数的代码，或��用另一个回调函敎ͼ��q�样�~�程��h��灉|��性就比较大了�?/p>
调用�U�定

　　上面的代码中�Q�可在函数原型中扑ֈ�__stdcall�Q�因为它以双下划�U�打��_��所以它是一个特定于�~�译器的扩展�Q�说到底也就是微软的实现。�Q何支持开发基于Win32的程序都必须支持�q�个扩展或其�{��h物。以__stdcall标识的函 ��C��用了标准调用�U�定�Q��ؓ什么叫标准�U�定呢，因�ؓ所有的Win32 API�Q�除了个别接受可变参数的除外�Q�都使用它。标准调用约定的函数在它们返回到调用者之前，都会从堆栈中�U�除掉参敎ͼ��q�也是Pascal的标准约定。但在C/C++中，调用�U�定是调用者负责清理堆栈，而不是被调用函数�Q��ؓ强制函数使用C/C++调用�U�定�Q�可使用__cdecl。另外，可变参数函数也��? C/C++调用�U�定�?br>
　　Windows操作�pȝ��采用了标准调用约定（Pascal�U�定�Q�，因�ؓ其可减小代码的体�U�。这点对早期的Windows来说非常重要�Q�因为那时它�q�行在只�?40KB内存的电脑上�?br>
　　如果你不喜欢__stdcall�Q�还可以使用CALLBACK宏，它定义在windef.h中：

#define CALLBACK __stdcallor

#define CALLBACK PASCAL //而PASCAL在此�?defined成__stdcall

　　作�ؓ回调函数的C++�Ҏ��

　　因�ؓ�q�x��很可能会使用到C++�~�写代码�Q�也�怼�惛_��把回调函数写成类中的一个方法，但先来看看以下的代码�Q?br>

class CCallbackTester
{
　public:
　int CALLBACK CompareInts(const byte* velem1, const byte* velem2);
};

Bubblesort((byte*)array, 5, sizeof(array[0]),
&CCallbackTester::CompareInts);

　　如果使用微��Y的编译器�Q�将会得��C��面这个编译错误：

error C2664: 'Bubblesort' : cannot convert parameter 4 from 'int (__stdcall CCallbackTester::*)(const unsigned char *,const unsigned char *)' to 'int (__stdcall *)(const unsigned char *,const unsigned char *)' There is no context in which this conversion is possible

　　�q�是因�ؓ非静态成员函数有一个额外的参数�Q�this指针�Q�这��迫使你在成员函数前面加上static。当�Ӟ��q�有几种�Ҏ��可以解决�q�个问题�Q�但限于��幅�Q�就不再��了�?/p>

RichardHe 2008-07-05 13:39 发表评论

Boost.Singals 教程

RichardHe — Fri, 04 Jul 2008 05:23:00 GMT
     摘要: 来自http://www.shnenglu.com/jinq0123/archive/2008/06/30/boostsignalstutorial.html Boost.Singals 教程 Home Libraries People ...  阅读全文

RichardHe 2008-07-04 13:23 发表评论

[摘录]回调函数与�{�U�表

RichardHe — Fri, 04 Jul 2008 05:18:00 GMT
��http://www.shnenglu.com/zhaoyg/archive/2008/07/03/55206.html

摘录�?《C和指针�?strong>
1.回调函数
�q�里有一个简单的函数,它用于在一个单链表中查找一个�?它的参数是一个指向链表第一个节点的指针以及那个需要查扄��?
Node* search_list(Node* node,int const value)
{
   while(node!=NULL)
{
    if(node->value==value) break;
    node=node->link;
}
return node;
}
�q? 个函数看上去相当��?但它只适用于��gؓ整数的链�?如果你需要在一个字�W�串链表中查�?你不得不另外�~�写一个函�?�q�个函数和上面那个函数的�l�大部分�? 码相�?只是�W�二个参数的�c�d��以及节点值的比较�Ҏ��不同.一�U�更为通用的方法是查找函数与类型无�?�q�样它就能用于�Q何类型的值的链表,我们必须对函数的两个斚w��q�行修改,使它与类型无�?
首先我们必须改变比较的执行方�?�q�样函数��可以对��M��c�d��的��D��行比�?�q�个目标听上��d��象不可能,如果�? �~�写语句用于比较整型�?它怎么�q�可能用于其他类型如字符串的比较�?解决�Ҏ��是使用函数指针,调用者编写一个函�?用于比较两个�?然后把一个指向这个函数的指针作�ؓ参数传递给查找函数.然后查找函数调用�q�个函数来执行值的比较,使用�q�种�Ҏ��,��M��c�d��的值都可以�q�行比较.我们必须修改的第二个斚w��? 向函��C��递一个指向值的指针而不是本�w?函数�׃��个void *形参,用于接收�q�个参数,然后指向�q�个值的指针便传递给比较函数,�q�个修改使字�W�串和数�l�对象也可以被��?字符串和数组无法作�ؓ参数传递给函数,但指向它们的指针可以.
使用�q�种技巧的函数�?回调函数"(callback function);因�ؓ用户把一个函数指针作为参��C��递给其他函数,后者将"回调"用户的函�?��M��时�?如果你所�~�写的函数必��能够在不同的时��L��? 不同�c�d��的工作或执行只能由函数调用者定义的工作,你都可以使用�q�个技�?许多�H�口�pȝ��使用回调函数�q�接多个动作,如拖拽鼠标和点击按钮来指定用��L��序中的某个特定函�?我们无法在这个上下文环境中�ؓ回调函数�~�写一个准��的原型,因�ؓ我们�q�不知道�q�行比较的值的�c�d��.事实�?我们需要查扑և�数能作用于�Q�? �c�d��的�?解决�q�个��N��的方法是把参数类型声明�ؓ"void *",表示"一个指向未知类型的指针".

/***在一个单链表中查找一个指定值的函数,它的参数是一个指向链表第一个节�?br>   **的指�?一个指向我们需要查扄��值的指针和一个函数指�?它所指向的函�?br>   **用于比较存储于此链表中的�c�d��的�?
*/
#include "node.h"
Node* search_list(Node *node,void const *value, int(*compare)(void const*,void const*)) //函数声明;
{
while   (node!=NULL)
{
    if(compare(&node->value,value)==0)   break;
    node=node->link;
}
return node;
}
同时注意虽然函数不会修改参数node所指向的�Q何节�?但node�q�未声明为const。如果node被声明�ؓconst,函数不得不返回一个const�l�果�Q�这��限制调用程序，它便无法修改查找函数所扑ֈ�的节炏V�?br> 在一个特定的链表中进行查找时�Q�用户需要编写一个适当的比较函敎ͼ��q�把指向该函数的指针和指向需要查扄��值的指针传递给查找函数�?br>例如�Q�下面是一个比较函敎ͼ�它用于在一个整数链表中�q�行查找�?br>int compare_ints(void const* a,void const* b)
{
    if(*(int*)a==*(int*)b)     return 0;
    else     return 1;
}
�q�个函数��像下面�q�样使用�Q?br>desired_node=search_list(root,&desired_value,compare_ints);

2.转换表（jump table)
转移表最好用个例子来解释。下面的代码�D�取自一个程序，它用于实��C��个袖珍式计算器。程序的其他部分已经��d��两个敎ͼ�op1和op2�Q�和一个操作符�Q�oper)。下面的代码�Ҏ��作符�q�行��试�Q�最后决定调用哪个函数�?br>switch(oper)
{
case ADD:   result=add(op1,op2);break;
case SUB:    result=sub(op1,op2);break;
case MUL:    result=mul(op1,op2);break;
case DIV:     result=div(op1,op2);break;
......
}

      对于一个新奇的��h��上百个操作符的计��器�Q�这条switch语句��会非常之长。�ؓ什么要调用函数来执行这些操作呢�Q�把具体操作和选择操作的代码分开是一�U? 良好的设计方案。更为复杂的操作��肯定以独立的函数来实现�Q�因为它们的长度可能很长。但即��是简单的操作也可能具有副作用�Q�例如保存一个常量值用于以后的操作�?br>��Z��使用switch语句�Q�表�C�操作符的代码必��L��整数。如果它们是从零开始连�l�的整数�Q�我们可以��用�{换表来实现相同的��d��。�{换表��是一个函数指针数�l��?br>创徏一个�{换表需要两个步骤。首先，声明�q�初始化一个函数指针数�l�。唯一需要留心之处就是确保这些函数的原型出现在这个数�l�的声明之前�?/p>
double add(double,double);
double sub(double,double);
double mul(double,double);
double div(double,double);

double (*oper_func[])(double,double)={add,sub,mul,div,...}�Q?/p>
      初始化列表中各个函数名的正确��序取决于程序中用于表示每个操作�W�的整型代码。这个例子假定ADD�?�Q�SUB�?�Q�MUL�?�Q�接下去以此�c�L��?br>      �W�二个步骤是用下面这条语句替换前面整条switch语句�Q?br>result=oper_func[oper](op1,op2);
oper从数�l�中选择正确的函数指针，而函数调用操作符��执行这个函数�?/p>

RichardHe 2008-07-04 13:18 发表评论

MD5��法的C++实现

RichardHe — Wed, 25 Jun 2008 09:12:00 GMT
     摘要: 来自http://www.shnenglu.com/ant/archive/2007/09/11/31886.html MD5��法的C++实现 1. Introduction MD5��法是一�U�消息摘要算�?Message Digest Algorithm)�Q�此��法以�Q意长度的信息(message)作�ؓ输入�q�行计算�Q��生一�?28-bit(16-byte)的指�UҎ��报文摘要(finge...  阅读全文

RichardHe 2008-06-25 17:12 发表评论

��Z��C++有限状态机的实现技�?调查报告)

RichardHe — Fri, 13 Jun 2008 07:01:00 GMT
     摘要: 一.引言�a� �?限状态机是一�U�用来进行对象行为徏模的工具�Q�其作用主要是描�q�对象在它的生命周期内所�l�历的状态序列，以及如何响应来自外界的各�U�事件。在面向对象的��Y�?�pȝ��中，一个对象无论多么简单或者多么复杂，都必然会�l�历一个从开始创建到最�l�消亡的完整�q�程�Q�这通常被称为对象的生命周期。一般说来，对象在其生命期内是不可能完全孤立的，它必��通过发送消息来影响其它对象�Q�或者通过接受消息来改变自�w�。在...  阅读全文

RichardHe 2008-06-13 15:01 发表评论

RichardHe — Fri, 13 Jun 2008 06:48:00 GMT
有限状态机�Q�Finite State Machine或者Finite State Automata)是��Y仉��域中一�U�重要的工具�Q�很多东西的模型实际上就是有限状态机�?br>
最�q�看了一些游戏编�E�AI的材料，感觉游戏中的AI�Q�第一要说的就是有限状态机来实现精�늚�AI�Q�然后才是A*寻�\�Q�其他学术界讨论比较多的��经�|�络、模�p�控制等问题�q�不是很热�?br>
FSM的实现方式：
1�Q?switch/case或者if/else
�q�无意是最直观的方式，使用一堆条件判断，会编�E�的人都可以做到�Q�对��单小巧的状态机来说最合适，但是毫无疑问�Q�这��L��方式比较原始�Q�对庞大的状态机难以�l�护�?br>
2�Q?状态表
�l�护一个二�l�状态表�Q�横坐标表示当前状态，�U�坐标表�C��入，表中一个元素存储下一个状态和对应的操作。这一招易于维护，但是�q�行旉��和存储空间的代�h较大�?br>
3�Q?使用State Pattern
�? 用State Pattern使得代码的维护比switch/case方式�E�好�Q�性能上也不会有很多的影响�Q�但是也不是100�Q�完��。不�q�Robert C. Martin做了两个自动产生FSM代码的工��P��for java和for C++各一个，在http://www.objectmentor.com/resources/index上有免费下蝲�Q�这个工��L��输入是纯文本的状�? 机描�q�ͼ�自动产生�W�合State Pattern的代码，�q�样developer的工作只需要维护状态机的文本描�q�ͼ�每必要冒引入bug的风险去�l�护code�?br>
4�Q?使用宏定义描�q�状态机
一般来��_��C++�~�程中应该避免��?define�Q�但是这主要是因为如果用宏来定义函数的话�Q�很�Ҏ��产生�q�样那样的问题，但是巧妙的��?�q�是能够产生奇妙的效果。MFC��是使用宏定义来实现大的架构的�?br>在实现FSM的时候，可以把一些繁琐无比的if/else�q�有花括��L��l�合攑֜�宏中�Q�这��P��在代码中可以3�Q�中状态机描述文本一样写�Q�通过�~�译器的预编译处理��?�Q�一��L��效果�Q�我见过产生C代码的宏�Q�如果要产生C++代码�Q�己软MFC可以�Q�那么理��Z��也是可行的�?img src ="http://www.shnenglu.com/richardhe/aggbug/53131.html" width = "1" height = "1" />

RichardHe 2008-06-13 14:48 发表评论

RichardHe — Thu, 05 Jun 2008 06:17:00 GMT
C++标准库中的文件流�c�L��供的各种操作中没有直接获得正在操作的文�g的大��的函数。要获得文�g大小得�{个弯�Q�用如下的方�?br>    假设我们有了一个已�l�打开的文件对象ifile�?br>    先将文�g内的位置指针�U�d��文�g��?br>    ifile.seekg( 0, ios::end );
    再读取当前位�|�，�q�就是文件的大小了�?br>    long filelength = ifile.tellg();
��:http://www.shnenglu.com/walkspeed/archive/2007/05/02/23336.html

RichardHe 2008-06-05 14:17 发表评论

接口设计的要点（接口不应被��用者直接销毁）

RichardHe — Wed, 04 Jun 2008 07:39:00 GMT

接口设计的要点（接口不应被��用者直接销毁）
接口在��用后�Q�不需要也不允许用户销�?br>
接口用来通讯的。虽然在C++中，接口的一般用指针实现�Q�但它代表的是一�U�通讯方式�Q�而不是资源的
位置。请求者在使用完后不应�ȝ��接销毁这个指针，而应由接口的提供者去��理�?br>
接口的提供者要��理接口兌��的实体的生命周期�Q�而且�q�有知道接口的��用情冉|��能管理接口�?br>
接口于实体之间有兌��Q�这表明实体要在接口前创建，要在接口后销毁。设计中接口提供者通过接口�?br>计数�Q�来��理接口的状态。有一个请求者就��接口计数增加一�Q�接口每被赋��g��ơ接口计��C��增加一��?br>�?br>
接口的��用者在使用完后�Q�要��接口返回给接口提供者，而不是自��q��接销毁。因为接口不是被使用�?br>甌��的资源，而是用户要求另一个对象通讯的通道。所以用完后要返�q�给接口提供者。接口提供者每�?br>��C��个接口的�q�还�Q�就减少�q�个接口的计��C��ơ�?br>
在要销毁接口关联的实体�Ӟ��先要��查这个接口是否还有��用者，如果有，��p��通知使用者，要求它们
�q�还接口。在接口没有使用者的情况下常能销毁实体（�q�样比较安全�Q�当然也可以��销毁）�?br>
同一个接口可能对应多个实体，不过用户是感觉不到的。但是接口提供者一定要��理�q�种接口于不同的
实体之间的关联关�p�，保证对不同的实体销毁时�Q�要收回与这个实体关联的所有接口�?img src ="http://www.shnenglu.com/richardhe/aggbug/52163.html" width = "1" height = "1" />

RichardHe 2008-06-04 15:39 发表评论

在C++中侦��内嵌类型的存在

RichardHe — Wed, 04 Jun 2008 07:23:00 GMT
     摘要: 现在学校里假如不止学生教师，�q�有工�h�Q�警卫等其它人员。如果他们不会在�c�d��部typedef��M��东西�Q�则Register需要一�U�机制以��定T内部是否typedef了某个标识符�Q�例如person_tag�Q�。如果没有，��默认处理。如果有�Q�则再进行更详细的分�c�R�?动机(Motivation) 假设一所大学的注册系�l�提供了一个注册函敎ͼ� template...  阅读全文

RichardHe 2008-06-04 15:23 发表评论

boost源码剖析之：泛型�~�程�_��type_traits

RichardHe — Wed, 04 Jun 2008 07:22:00 GMT
     摘要: 本文仅介�l�一些技术性较强的traits。由于traits的定义往往重复代码较多�Q�所以必要时本文仅剖析其底层机制。所有源码均摘自相应头文件中�Q��ؓ使源码简�z�，所有的宏均已展开。由于traits技巧与�~�译�q�_��息息相关�Q�某些��^台可能不支持模板偏特化�?动机使用traits的动��Z��般有三种�Q�分�z�、效率、��某些代码通过�~�译�? 分派下面有一个模板函敎ͼ�假设一个动物收容组�l�提供了它，�?..  阅读全文

RichardHe 2008-06-04 15:22 发表评论

boost源码剖析之：boost::multi_array

RichardHe — Wed, 04 Jun 2008 07:21:00 GMT
     摘要: 本文只是��multi_array最基本的功能代码做了一个扼要的�?析，正如文章开始所��_��multi_array�q�有许多很有用的�Ҏ��，如果读者想充分了解multi_array的运作机制与实现技巧，��p��深入完整地分析multi_array的代码吧�Q�相信一定会大有收获的！动机       C++是一门自��q��语言�Q�允�怽�自由的表达自��q��意图�Q�对...  阅读全文

RichardHe 2008-06-04 15:21 发表评论

RichardHe — Wed, 04 Jun 2008 07:21:00 GMT
     摘要: 首先�Q�any�c�里面一定要提供一个模板构造函数和模板operator=操作�W�。其�ơ，数据的存放之所是个问题�Q�显然你不能��它保存在any�c�M��Q�那会导致any�c�L��为模板类�Q�后者是明确不被允许的。结论是�Q��ؓ容器准备一个非泛型的基�c�，而让指针指向该基�c�R�?动机 C++是强�c�d��语言�Q�所有强�c�d��语言对类型的要求都是苛刻的，�c�d��一有不合编译器��׃��抱怨说不能��某某类型�{换�ؓ某某�c�d��Q�当然如果在�c�d��之间提供了�{�?..  阅读全文

RichardHe 2008-06-04 15:21 发表评论

boost源码剖析之：Tuple Types

RichardHe — Wed, 04 Jun 2008 07:20:00 GMT
     摘要: 了解tuple的设计目标十分重要。下面两个细节设计目标才是真正需要和体现技术的地方�Q�容我向你阐�q�它们：tuple中的数据成员的个数应该具有某�U�动态特性；tuple 必须提供某种途径以获取它内部保存的数倹{�?动机[1] 假设你有�q�样一个函敎ͼ�它接受两个整型数据�ƈ�q�回它们整除的结果，像这��P�� int DevideInts(int n,int d) { &nbs...  阅读全文

RichardHe 2008-06-04 15:20 发表评论

刘未鹏之《boost源码剖析》系列多重回调机制signal

RichardHe — Wed, 04 Jun 2008 07:19:00 GMT
     摘要: 上篇�Q�架构篇引入所�?#8220;事�g”机制�Q�简而言之，��是用户��自��q��一个或多个回调函数挂钩到某�?#8220;事�g”上，一�?#8220;事�g”被触发，所有挂钩的函数都被调用�? 毫无疑问�Q�事件机制是个十分有用且常用的机�Ӟ��不然C#也不会将它在语言层面实现了�? 但是C++语言�q�无此种机制�? �q�运�?..  阅读全文

RichardHe 2008-06-04 15:19 发表评论

Boost.Bind的基��使用

RichardHe — Wed, 04 Jun 2008 07:01:00 GMT

Boost.Bind的基��使用
当我们��用函数时习惯于C函数的格�?卛_��下�Ş�?br>resulttype funname( arglist );
�q�回值类�?函数�? 参数列表 );

在Boost.Function中，我们可以方便的定义定义函数对象。不�q�在定义用来表示�c�L��员函数的函数对象�?br>�W�一个参数是�c�L��针。而且在调用时�Q�要传入一个类实例的指针。这��L��h��q�不是很方便�Q�因��用�?br>要知道类实例。这实际上没有实现解耦。而解耦是我们使用回调或委托设计的一个目标�?br>
��Z��解决�q�个问题�Q�我们要使用Boost.Bind�?br>
Boost.Bind是一个函数对象工厂。他用来产生我们需要的函数对象。好了，有了它，你可以在你设计中�?br>量��用Boost.Function。不用再��d��义类成员函数形式的函数对象啦�Q�只用定义普通函数对象�?br>
一个简单的例子

class CExample
{
public:
    bool printstr( const std::string &str )
    {
        std::cout << "CExample::printstr" << str << std::endl;
        return true;
    }
};

//定义一个函数对�?br>boost::function< bool ( const std::string& ) > printstr;

//用Boost.Bind创徏一个函数对象，赋给printstr
CExample example;
printstr = boost::bind( &CExample::printstr, &example, _1 );

好了�Q�我们创��Z��一个函数对象，而且调用时不再需要类实例拉。用Boost.Function和Boost.Bind大大
的简化了Command模式的实现�?br>
在上面的例子中要个古怪的对象"_1"。这个叫做站位符�Q�他代表�q�个位置有个参数�Q�但现在�q�不知道�?br>数是什么。_1代表参数列表中的�W�一个位�|�上的参数。Boost.Bind一共定义了9个站位符对象。如�?br>_1,_2,_3,_4,_5,_6,_7,_8,_9。分别代表参数列表中位子�?br>
Boost.Bind产生的函数对象可以直接��用，利用上面的例子�?br>
bool b = boost::bind( &CExample::printstr, &example, _1 )( "Hello World" );

RichardHe 2008-06-04 15:01 发表评论

RichardHe — Wed, 04 Jun 2008 06:50:00 GMT
前奏

　　如你所知，Boost库是个特性完备，且具备工业强度的库，众多C++权威的参与��其达��C��d��造极的程度。尤�?a class="bluekey" target="_blank">泛型的强大威力在其中被发挥得淋漓��致�Q��o人瞠目结舌�?br>
　　然而弱水三千，我们只取一瓢饮。下面，我试图从最单纯的世界开始，一步一步带领你�q�入源码的世界，��L��I�boost::function(下文��U�function)内部的精微结构�?br>
　　通常 �Q�在单纯的情况下�Q�对函数�?a class="bluekey" target="_blank">调用��单而且直观�Q�像�q�样�Q?br>

int fun(int someVal);

int main(){
　fun(10);
}

　　然而你可能需要在某个时刻��?a class="bluekey" target="_blank">函数指针保存下来�Q��ƈ在以后的另一个时刻调用它�Q�像�q�样�Q?br>

int fun(int);
typedef int (*func_handle)(int);

int main(){
　func_handle fh=fun;
　... //do something
　fh(10);
}

　　但是�Q�如果fun形式�?a class="bluekey" target="_blank">void fun(int)呢？如你所见，fun可能有无数种形式�Q�如果对fun的每一个�Ş式都typedef一个对应的func_handle�Q�则�E�序员会焦头烂额�Q�不胜其扎ͼ�代码也可能变得臃肿和丑陋不堪�Q�甚臛_��果fun是仿函数呢？

　　�q�运的是C++泛型可以使代码变�?a class="bluekey" target="_blank">优雅�_�致�Q�面�Ҏ��数种的可能，泛型是最好的选择�?因此�Q�你只是需要一个能够保存函�?a class="bluekey" target="_blank">指针的泛�?a class="bluekey" target="_blank">模板�c?/a>(对应于Command模式)�Q�因为泛�?a class="bluekey" target="_blank">�~�程有一个先天性的优势——可以借助�~�译�?/a>的力量在�~�译期根据用��h��供的型别信息化��n千万(��L��?�Q�所以一个泛型的�c�d��以有无限个具��C��Q�也��是说可以保存无限多�U�可能型别的函数或类似函数的东西(如，仿函�?。这个类(在Boost库中的类名�ؓfunction)与函数指针相比应该有以下一些优势：

　　¨ 同一个function对象应能够接受与它�Ş式兼容的所有函数和仿函�?例如�Q?br>

int f1(int); //�q�是个函敎ͼ�形式�?int(int)
short f2(double); //�q�个函数形式�?short(double)

struct functor //�q�是个仿函数�c�，形式为int(int)
{
　int operator()(int){}
};

functor f3; //创徏仿函数对�?br>
boost::function�Q�int(int)�Q?func; // int(int)型的函数或仿函数
func = f1; //接受f1
func(10); //调用f1(10)
func = f2; //也能接受short(double)型的f2
func(10); //调用f2(10)
func = f3; //也能接受仿函数f3
func(10); //调用f3(10)

　　¨ function应能够和参数 �l�定以及其它function-construction�?a class="bluekey" target="_blank">协同工作。例如，function应该也能够接受std::bind1st�q�回的仿函数。这一点其实由�W�一点已�l�有所保证�?br>
　　¨ 当接受的一个空的仿函数对象被调用的时候function应该有可预期的行为�?br>
　　昄��Q�第一�Ҏ��我们的重点，所谓�Ş式兼容，��是��_��对于�Q?br>

R1 (T0,T1,T2,...,TN) =�Q?FunctionType1
R2 (P0,P1,P2,...,PN) =�Q?FunctionType2

　　两种�c�d��的函敎ͼ��q�义�Q�，只要满��Q?br>
　　1. R2能够隐式转换为R1

　　2. 所有Ti都能够隐式�{换�ؓPi (i�?,1,2,...)

那么��p��Q�boost::function�Q�FunctionType1�Q�可以接受FunctionType2�c�d��的函�?注意�Q�反之不�?。支持这一论断的理由是�Q�只要Ti能够隐式转型为Pi�Q�那么参数被转发�l�真实的函数调用��是安全的，�q�且如果R2能够隐式转型为R1�Q�那么返回真实函数调用所�q�回�? 值就是安全的。这里安全的含义是，C++�c�d��pȝ��认�ؓ隐式转换不会丢失信息�Q�或者会�l�出�~�译警告�Q�但能够通过�~�译�?br>
　　后面你会看到�Q�boost::function通过所谓的invoker非常巧妙地实��C��q�点�Q��ƈ且阻止了被�Ş式不兼容的函数赋值的操作�?br>探险

　　好吧�Q�准备好�Q�我们要出发了，�q�行深入源码世界的探险�?br>
　　先看一个function的最��单的使用�Q?br>

int g(int); //��Z��让代码简单，假设g有定义，以后的代码都会如�?br>function�Q�int(int)�Q?f(g);
f(0);

　　间奏——R(T1,T2,...)函数�c�d��

　　虽然�q�个间奏未免早了点儿�Q�但是�ؓ了让你以后不会带着�q�h��Q�这昄��是必要的。请保持耐心�?br>
或许你会�Ҏ��板参数int(int)感到陌生�Q�其实它是个函数型别——函数g的确切型别就是int(int)�Q�而我们通常所看到的函数指针型别int (*)(int)则是&g的型别。它们的区别与联�p�d��于：当把g作�ؓ一个��D��行拷贝的时候（例如�Q�按��g��参）�Q�其�c�d��׃��由int(int)退�? 为int(*)(int)�Q�即从函数类型退化�ؓ函数指针�c�d��——因��Z��语义上说�Q�函��C��能被“按值拷�?#8221;�Q�但�w��ؓ函数指针的地址值则是可以被拯��的。另一斚w��Q�如果g被绑定到引用�Q�则其类型不会退化，仍保持函数类型。例如：

template�Q�class T�Q?br>
void test_func_type(T ft) //按��g��递，�c�d��退�?br>{
　static_cast�Q�int�Q?ft); //引发�~�译错误�Q�从而看出ft的类型�ؓ退化后的函数指�?br>}

int g(int); //函数g�Q�名字g的类型�ؓint(int)
test_func_type(g); //注意�Q��ƈ�?amp;g�Q�参数g的类型将会退化�ؓ函数指针�c�d��
int (&ref_f)(int) = g; //注意�Q��ƈ�?#8220;= &g”�Q�因为绑定到引用�Q�类型�ƈ不退�?/td>

当然�Q�这��L��代码不能通过�~�译�Q�因为static_cast�Q�＞昄��不会让一个函数指针�{换�ؓint�Q�然而我们就是要它通不�q�编译，�q�样我们才能�H�视�? 按��g��递的参数ft的类型到底是什么，从编译错误中我们看出�Q�ft的类型是int(*)(int)�Q�也��是��_��在按��g��递的�q�程中，g的类型退化�ؓ函数�? 针类型，变得�?amp;g的类型一样了。而ref_t的类型则是引用，引用�l�定则没有引��L��型退化�?br>
　　��h��意，函数�c�d��乃是个极其特�D�的�c�d��Q�在大多数时候它都会退化�ؓ函数指针�c�d��Q�以便满��x��贝语义，只有面对引用�l�定的时候，能够�l�持原来的类型。当�Ӟ��对于boost::function�Q��L��按值拷贝�?br>
　　�l�箋旅程

　　好吧�Q�回�q�神来，我们�q�有更多地带要去探究�?br>
　　function�Q�int(int)�Q�实际上�q�行了模板偏特化�Q�Boost库给function的类声明为：

template�Q�typename Signature, //函数�c�d��
typename Allocator = ...
�Q?//Allocator�q��重点�Q�故不作介绍

class function;

　　事实上function�c�d��是个薄薄的外覆（wrapper�Q�，真正起作用的是偏特化版本�?br>
对于function�Q�R(T0)�Q��Ş式，偏特化版本的function源码像这�?实际上在boost源代码中你看不到模板参数T0的声明，也看不到 function1�Q�它们被宏替换掉了，那些�_��y的宏是�ؓ了减��可见的代码量，至于它们的细节则又是一个世界，以下代码可看作对��那些��o人眼��q݋��q��宏展开后所得到的代码，��h��更好的可��L�?�Q?br>
　　摘自�Q?#8221;boost/function/function_template.hpp”

template�Q�typename R,typename T0,typename Allocator�Q?br>class function�Q�R(T0),Allocator�Q?//对R(T0)函数�c�d��的偏特化版本

:public function1�Q�R,T0,Allocator�Q?//为R(T0)形式的函数准备的基类�Q�在下面讨论
{
　typedef function1�Q�R,T0,Allocator�Q?base_type;
　typedef function selftype;
　struct clear_type{}; //马上你会看到�q�个�y��؜的类型定义的作用
　public:
　　function() : base_type() {} //默认构�?br>　　template�Q�typename Functor�Q?//模板化的构造函敎ͼ��Z��能够接受形式兼容的仿函数对象
　　function(Functor f, typename enable_if�Q?br>　　　　(ice_not�Q?is_same�Q�Functor, int�Q?:value)�Q?:value),
　　　　int
　　�Q?:type = 0) �Q�base_type(f){}

　function(clear_type*) : base_type() {} //�q�个构造函数的作用在下面解�?br>　self_type& operator=(const self_type& f) //同类型function对象之间应该能够赋�?br>　{
　　self_type(f).swap(*this); //swap技巧，�l�节见《Effective STL�?br>　　return *this;
　}
　...
};

enable_if

　　你一定对模板构造函��C��出现的那个冗长的enable_if�Q?..�Q�的作用心存疑惑�Q�其实它的作用说�I�了很简单，��是�Q�当用户构造：

function�Q�int(int)�Q?f(0);

　　的时候，��该�Q�带有enable_if的）构造函��C��重蝲册��的候选集中踢掉。��重蝲册��的结果�ؓ选中�W�三个构造函敎ͼ�

function(clear_type*):base_type(){}

　　�? 而进行缺省构造�? 而说得冗长一点就是：当f的类型——Functor——不是int�Ӟ��该构造函数就�?#8220;有效�Q�enable�Q?#8221;的，会被重蝲册��选中。但如果用户提供了一 �?�Q�用意是构造一个空(null)的函数指针，那么该函数就会由�?#8220;SFINAE”原则而被从重载决议的候选函��C��t�掉。�ؓ什么要�q�样呢？因�ؓ该构造函数负责把��切的f保存��h��Q�它假定f�q��0。那应该选择谁呢�Q�第三个构造函敎ͼ�其参数类型是clear_type*�Q�当�Ӟ��0可以被赋�l��Q何指针，所以它被选出�Q�执行缺省的构造行为�?br>基类 functionN

　　function的骨架就�q�些。也�怽�会问�Q�function作�ؓ一个仿函数�c�，怎么没有�? 载operator()——这可是�w��ؓ仿函数的标志啊！别急，function把这些烦人的��d��都丢�l�了它的基类functionN�Q�根据情况不同，N�? 能�ؓ0�Q?�Q?...�Q�说具体一点就是：�Ҏ��用户使用function时给出的函数�c�d��Q�function��会�l�承自不同的基类——如果用��L��出的函数�c? 型�ؓ“R()”形式的，即仅有一个参敎ͼ�则function�l�承自function0�Q�而对于R(T0)形式的函数类型，则��承自function1�Q�依此类推。前面说�q�，function只是一层外覆，而所有的�U�密都在其基�c�functionN中！

　　不知道你有没有发玎ͼ�function的骨架中也几乎没有用到函数类型的信息�Q�事实上�Q�它也将�q�些信息一股脑儿抛�l�了基类。在�q�过�E�中�Q��؜沌一团的int(int)型别被拆解�ؓ两个单独的模板参��C��l�基�c?

template�Q�typename R,typename T0,typename Allocator�Q?br>class function�Q�R(T0),Allocator�Q?//R(T0)整个��Z��型别
:public function1�Q�R,T0,Allocator�Q?//拆解��Z��个模板参数R,T0传给基类

　　好了�Q�下面我们深入基�c�function1。真正丰富的宝藏在里面�?br>
　　function1

　　function1的源代码像这�?与上面一��P��事实上有些代码你是看不到的，��Z��不让你迷惑，我给出的是将宏展开后得到的代码):

　　摘自�Q?#8221;boost/function/function_template.hpp”

template�Q�typename R,typename T0,class Allocator = ...�Q?br>
class function1:public function_base //function_base负责��理内存
{
　...
　public:
　　typedef R result_type; //�q�回�c�d��
　　typedef function1 self_type;
　　function1() : function_base(),invoker(0){}//默认构�?br>　　template�Q�typename Functor�Q?br>　　function1(Functor const & f, //模板构造函�?br>　　　typename enable_if�Q?..�Q?:type = 0) :
　　　function_base(),
　　　invoker(0)
　　　{
　　　　this-�Q�assign_to(f); //�q�儿真正�q�行赋��|��assign_to的代码在下面列出
　　　}

　　function1(clear_type*) : function_base(), invoker(0){} //该构造函��C��面解释过
　　function1(const function& f) : //拯��构造函�?br>　　function_base(),
　　invoker(0){
　　　this-�Q�assign_to_own(f); //专用于在function之间赋值的assignment
　　}

　　result_type operator()(T0 a0) const //�w��ؓ仿函数的标志�Q?br>　　{
　　　//下面负责调用指向的函�?br>
　　　if (this-�Q�empty())
　　　　boost::throw_exception(bad_function_call());
　　　　//�q�里�q�行真正的函数调用，使用invoker

　　　　internal_result_type result = invoker(function_base::functor,a0);
　　　　return static_cast�Q�result_type�Q?result);
　　}

　　template�Q�typename Functor�Q?br>　　void assign_to(Functor f) //所有的构造函数都调用它！��h��多个重蝲版本�?br>　　{
　　　//以一个get_function_tag萃取出Functor的类�?category)!
　　　typedef typename detail::function::get_function_tag�Q�Functor�Q?:type tag;
　　　this-�Q�assign_to(f, tag());//�Ҏ��不同�c�d��的Functor采取不同的assign�{�略�Q?br>　　}

　　get_function_tag�Q�＞能萃取出Functor的类�?category)�Q�有下面几种�c�d��

　　struct function_ptr_tag {}; //函数指针�c�d��

　　struct function_obj_tag {}; //仿函数对象类�?br>
　　struct member_ptr_tag {}; //成员函数�c�d��

　　struct function_obj_ref_tag {};//以ref(obj)加以��装的类别，��h��引用语义

　　struct stateless_function_obj_tag {}; //无状态函数对�?br>
　　满��以下所有条�Ӟ��

　　has_trivial_constructor

　　has_trivial_copy

　　has_trivial_destructor

　　is_empty

　　的仿函数对象�U�Cؓstateless�?br>
　　而对于不同的函数�c�d��Q�assign_to有各个不同的重蝲版本�Q�如下：

template�Q�typename FunctionPtr�Q?//如果是函数指针就调用�q�个版本

void assign_to(FunctionPtr f, function_ptr_tag) //�q�个版本针对函数指针
{
　clear();
　if (f){
　　typedef typename detail::function::get_function_invoker1�Q�FunctionPtr,R,T0�Q?:type invoker_type;
　　invoker = &invoker_type::invoke; //invoke是static成员函数

　　function_base::manager = //��理�{�略
　　　　 &detail::function::functor_manager�Q�FunctionPtr, Allocator�Q?:manage;

　　function_base::functor = //交给function的函数指针或仿函数对象指针最�l�在�q�儿保存
　　　function_base::manager(
　　　　detail::function::make_any_pointer((void (*)())(f)),
　　　　detail::function::clone_functor_tag);//实际上拷贝了一份函数指�?br>　}
}

...

typedef internal_result_type (*invoker_type)(detail::function::any_pointer,T0);
invoker_type invoker; //重要成员�Q�负责调用函敎ͼ�

};

　　你可能已�l�被�q�段“夹叙夹议”的代码弄得头昏脑涨了�Q�但�q�才刚刚开始！

　　function的底层存储机�?/strong>

　　请将目光转向上面的代码段末尾的assign_to函数中，其中有两行深色的代码�Q�分别对function_base里的manager和functor成员赋倹{��这两行代码肩负了保存各�U�函数指针的��d��?br>
manager是一个函数指针，它所指向的函��C��表管理策略，例如�Q�对于函数指针，仅仅作一�ơ赋��|��׃��存完毕了�Q�但是对于仿函数�Q�得额外分配一�ơ内存，然后��仿函数拯��到分配的内存中，�q�才完成了保存的��d��。这些策略根据函数的�c�d��而定�Q�上面代码中的assign_to函数是针对函数指针类别的重蝲版本�Q�所以manager的策略是不作��M��内存分配�Q�直接返回被转型�?#8220;void(*)()”�Q�利于在底层以统一的�Ş式保存）的函数指针就行了�Q�这从代�? 中可以看出�?br>
　　需要说明的是，对于函数指针�Q�function_base�q�不知道也不兛_��它要保存的函数指针是什么确切的�c�d��Q�只要是函数指针��p��Q�因为它��M��把该函数指针f转型�?#8220;void (*)()”�c�d��Q�然后保存在functor成员中，functor成员是一个union:

union any_pointer
{
void* obj_ptr; //��L��仿函数对象指针都可以用static_cast�Q�＞转型为void*�?br>const void* const_obj_ptr; //为const仿函数准备的
void (*func_ptr)(); //��L��函数指针都可以用reinterpret_cast�Q�＞转型为void(*)()�?br>char data[1];
};

　　�q�个any_pointer可以通过安全转型保存所有�Ş式的仿函数和函数指针�Q�承载在底层保存数据的�Q�?br>
　　function的调用机制——invoker

　　我们把目光�{到function1的定义的最底部�Q�那儿定义了它最重要的成员invoker�Q�它是一个函数指针，所指向的函数就是function的调用机制所在，invoker的类型�ؓ�Q?br>

typedef internal_result_type (*invoker_type)(any_pointer,T0);

前面已经说过�Q�any_pointer是个union�Q�可以保存�Q何类型的函数指针或函数对象，里面保存的是用户注册的函数或仿函敎ͼ�T0��? any_pointer中的函数的参数的型别�Q�对于不同情况，可能会有T1,T2�{�）。这也就是说�Q�invoker负责调用保存在any_pointer 中的用户提供的函数或仿函数�?br>
　　那么�Q�invoker�q�个函数指针到底指向什么函数呢——也��是��_��在什么时候invoker被赋��g��呢？我们再次把目光�{向assign_to函数�Q�其中有一行对invoker成员赋值的语句�Q�从�q�行语句出发我们可以揭露invoker的全部奥�U�：

invoker = &invoker_type::invoke; //invoke是static成员函数

请不要把�q�个invoker_type和上面那个函数指针型别invoker_type��h��h��Q�这个invoker_type是位�? assign_to函数中的一个局部的typedef�Q�所以隐藏了后者（即类作用域中的那个invoker_type——invoker成员的类型）。往上一行，你就看到�q�个局部型别invoker_type的定义了�Q?br>

typedef typename get_function_invoker1�Q?br>
FunctionPtr,R,T0�Q?:type invoker_type;

　　get_function_invoker1又是何物�Q�很昄��Q�这是个traits�Q�其内嵌�?:type会根据不同的模板参数表现��Z��同的�c�d��Q�在本例中，::type的类型将会被推导�?br>

function_invoker1�Q�int(*)(int),int,int�Q?/td>

　　而function_invoker1是个�c�L��板，其定义�ؓ�Q?br>

template�Q�typename FunctionPtr,
typename R�Q�typename T0�Q?//注意�q�里的模板参敎ͼ�后面会解�?br>
struct function_invoker1
{
　static R invoke(any_pointer function_ptr,T0 a0)
　{
　　FunctionPtr f = reinterpret_cast�Q�FunctionPtr�Q?function_ptr.func_ptr);
　　return f(a0);
　}
};

　　所以对invoker的赋值最�l�相当于�Q?br>

invoker=&function_invoker1�Q�int(*)(int),int,int�Q?:invoke;

　　而function_invoker1�Q�int(*)(int),int,int�Q?:invoke是静态成员函敎ͼ�它被实例化后相当于：

static int invoke(any_pointer function_ptr,int a0)
{
　//先�{型，再调用，注意�Q�这一行语句还有一个额外的作用�Q�在后面解释
　int (*f)(int) = reinterpret_cast�Q�int(*)(int)�Q?function_ptr.func_ptr);

　//因�ؓf指向的是用户保存在该function中的函数或仿函数�Q�所以这一行语句进行了真实的调用！
　return f(a0);
}

　　我们可以看出�Q�在invoke函数中，真正的调用现�w�了�?br>
　　如果接受的是仿函敎ͼ�则有function_obj_invoker1与它对应�Q�后者也是一个类似的模板�Q�它的invoke静态成员函数的形式也是�Q?br>

static R invoke(any_pointer function_obj_ptr,T0 a0);

　　其中function_obj_ptr是指向仿函数的指针，所以其invoke静态成员函��C��对它的调用语句是�q�样的：

FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);

return (*f)(a0); //调用用户的仿函数

最后一�U�可能：如果接受的是成员函数怎么办呢�Q�简单的�{�案是：boost::function�q�没有�ؓ成员函数作�Q何特�D�准备！理由也很��单， boost::function只要先将成员函数��装��Z��函数�Q�然后将其作��Z��般的仿函数对待就行了�Q�具体代码就不列了，STL中有一个函数模�? std::mem_fun��是用于��装成员函数指针的，它返回的是一个仿函数。boost中也对该函数模板做了扩充�Q��它可以接受�Q意多个参数的成员�? 数�?br>做一个，送一个——invoker的额外好�?/strong>

　　我们注意到function的构造和赋值函数及其基�cȝ��构造和赋值函数都是模板函敎ͼ��q�是因�ؓ用户可能提供函数也可能提供函数模板，但最关键的还是，functiont提供一�U�能力：对于function�Q�double (int)�Q�类型的泛型函数指针�Q�用户可以给它一个int(int)�c�d��的函数——是的，�q�是可行且安全的�Q�因为其�q�回值类型int可以安全的�{型�ؓ double�Q�而对于这�U�类型兼�Ҏ��的��查就在上面分析的invoke静态成员函��C��Q�这��是我们要说的额外好处——如果类型兼容，那么invoke函数 ��p��正常�~�译通过�Q�但如果用户�l�出�c�d��不兼容的函数�Q�就会得��C��个错误，�q�个错误是在�~�译器实例化invoke函数代码的时候给出的�Q�例如，用户如果�q�样写：

RT1 f(P1,P2); // RT1(P1,P2)函数�c�d��Q�这里的RT1,P1,P2假定已经定义�Q�这是一般化的符�?br>
function�Q�RT(P)�Q?f_ptr; //RT(P)函数�c�d��Q�同样假定RT,P已定�?br>
f_ptr = &f; //�c�d��不兼容，错误�Q?/td>

　　�q�就会导致编译错误，错误发生在invoke静态成员函��C��。下面我��׃ؓ你解释�ؓ什么�?br>
　　我想你对function_invoker1考的三个模板参数仍然心存疑惑�Q�我们再一�ơ来回顾一下其声明�Q?br>

template�Q�typename FunctionPtr,typename R�Q�typename T0�Q?

struct function_invoker1

　　我们�q�得把目光投向assign_to模板函数�Q�其中��用function_invoker1的时候是�q�样的：

typedef typename detail::function::get_function_invoker1�Q?br>
FunctionPtr,R,T0�Q?:type invoker_type;

　　�q�里�Q�给出的FunctionPtr,R,T0三个模板参数��会原封不动的传�l�function_invoker1�Q�那么对于我们上面的错误�C�Z��Q�这三个模板参数各是什么呢�Q?br>
　　首先�Q�我们很�Ҏ��看出�Q�FunctionPtr��是assign_to模板函数的模板参敎ͼ�也就是用户传递的函数或仿函数的类型，在我们的错误�C�Z��中，函数f的类型�ؓRT1(P1,P2)�Q�所�?br>

FunctionPtr = RT1(*)(P1,P2)

　　而R,T0则是用户在实例化function模板时给出的模板参数�Q�我们写的是function�Q�RT(P)�Q�，于是:

R = RT

T0 = P

　　所以，对于我们的错误示例，invoker_type的类型�ؓ�Q?br>

function_invoker1�Q?RT1(*)(P1,P2),RT,P�Q?/td>

　　对于�q�样一个function_invoker1�Q�其内部的invoke静态成员函数被实例化�ؓ�Q?br>

static RT invoke(any_pointer function_ptr,P a0)
{
　RT1 (*f)(P1,P2)= //FunctorPtr f =reinterpret_cast�Q�RT1(*)(P1,P2)�Q?function_ptr.func_ptr);
　return f(a0); //错啦�Q�瞧瞧f的型别，f接受一个P�c�d��的参数吗�Q�编译器在此打住�?br>　//�q�行语句的另一个隐含的��查是�q�回值类型匹配，f(...)�q�回RT1�Q�而invoke��d��q�回RT
}

　　看看最后一行语句，所有的��查都在那里了——我们最�l�把��?#8220;委托”�l�了C++底层的类型系�l��?br>
　　很精妙不是吗�Q�虽然在模板形式的assign_to函数中，看�v来我们�ƈ不关心到底用��L��的参数是何类型，看�v来用户可以把��M��函数或仿函数塞过来，但是一旦下面触及invoker的赋��|��得实例化invoke静态成员函敎ͼ�其中的：

return f(a0);

　　一下就把问题暴露出来了�Q�这�U�把�c�d��查�g�q�到最后，不得不进行的时候，由C++底层的类型系�l�来负责��查的手法的确很奇妙——看��h��我们没有在assign_to函数中及时利用类型信息进行类型检查，但是我们却�ƈ没有丧失��M��c�d��安全性，一切最�l�都逃不�q�C++底层的类型系�l�的考验�Q?br>
　　function如何对待成员函数

　　对于成员函数�Q�assign_to的重载版本只有一行：

this-�Q�assign_to(mem_fn(f));

　　mem_fun(f)�q�回一个仿函数�Q�它��装了成员函数f�Q�之后一切皆与仿函数无异�?br>
　　关于mem_fun的细节，�q�里��׃��多说了，大家可以参考STL中的实现�Q�相信很�Ҏ��看懂�Q�这里只��单的提醒一下，成员函数��装的效果是�q�样的：

R (C::*)(T0,T1,...) --�Q?R (*)(C*,T0,T1,...) �?R (*)(C&,T0,T1,...)

　　safe_bool惯用手法

　　如你所知，对于函数指针fptr�Q�我们可以这��h��试它�Q�if(fptr) ...�Q�所以function也应该提供这一�Ҏ��，然而如果直接重载operator 　bool()则会��D��下面的代码成为合法的:

function�Q�int(int)�Q?f;

bool b=f;

　　�q�显然不妥，所以function用另一个��y妙的手法替代它，既所谓的safe_bool惯用手法�Q�这在function定义内部的源码如下：

struct dummy { void nonnull(){};};

typedef void (dummy::*safe_bool)(); //��保safebool不能转型��Z�Q何其它类型！

operator safe_bool () const

{ return (this-�Q�empty())? 0 : &dummy::nonnull; }

�q�样�Q�当你写if(f)的时候，�~�译器会扑ֈ�operator safe_bool()�Q�从而将f转型为safe_bool�Q�这是个指针�c�d��Q�if语句会正��判定它是否为空。而当你试图把f赋给其它�c�d��的变量的时候则会遭到编译期的拒�l�——因为safe_bool无法向其它类型�{换�?br>

get_function_tag�Q�＞

　　get_function_tag�Q�＞用于萃取出函数所属类�?category)�Q�各个类别在源代码中已经列出�Q�至于它到底是如何萃取的�Q�这与本文关�p�M��是很　大，有一炚w��要提醒一下：函数指针�c�d��也是指针�c�d��Q�这听�v来完全是句废话，但是考虑�q�样的代码：

template�Q�typename T�Q?struct is_pointer{enum{value=0};};

template�Q�typename T�Q?struct is_pointer�Q�T*�Q�{enum{value=1};};

std::cout�Q�＜is_pointer�Q�int(*)(int)�Q?:value; //�q�将输出 1

　　也就是说int(*)(int)可以与T*形式匚w��Q�匹配时T为int(int)�?br>
　　最后一些细�?/strong>

　　1. 我没有给出function_base的源代码�Q�实际上那很��单，它最主要的成员就是union any_pointer型的数据成员

detail::function::any_pointer functor; //用于�l�一保存函数指针及仿函数对象指针

　　2. 我没有给出functor_manager的信息，实际上它与function的实现没有太大关�p�，它负责copy和delete函数对象�Q�如果必要的话。所以我��它略去�Q�它的源码在�Q?#8221;boost/function/function_base.hpp”里�?br>
　　3. 我给出的源代码是��宏展开后的版本�Q�实际的代码中充斥着让�h��D��~��ؕ的宏�Q�关于那些宏则又是一个奇妙的世界。Boost库通过那些宏省��M��许多可见代码量。随着函数参数的不同，那些宏会扩展出function2,function3...各个版本�?br>
　　本文只研�I�了int(int)型的情况�Q�其它只是参数数目的改变而已。经�q�宏的扩展，function的偏特化版本��有:

template�Q�typename R,typename Allocator�Q?br>
class function�Q�R(),Allocator�Q?public function0�Q�R,Allocator�Q?br>
{...};

template�Q�typename R,typename T0,typename Allocator�Q?br>
class function�Q�R(T0),Allocator�Q?public function1�Q�R,T0,Allocator�Q?br>
{...};

template�Q�typename R,typename T0,typename T1,typename Allocator�Q?br>
class function�Q�R(T0,T1),Allocator�Q?public function2�Q�R,T0,T1,Allocator�Q?br>
{...};

�{�更多版本，一共有BOOST_FUNCTION_MAX_ARGS+1个版本，BOOST_FUNCTION_MAX_ARGS��Z��个宏�Q�表�C�最多能够接受有多少个参数的函数及仿函数对象�Q�你可以重新定义�q�个宏�ؓ一个新��|��以控制function所能支持的函数参数个数的最大倹{��其中的 function0,function1,function2�{�名字也由宏扩展出�?br>  阅读关于 C++ 的全部文�?br>

RichardHe 2008-06-04 14:50 发表评论

RichardHe — Wed, 04 Jun 2008 06:45:00 GMT

Boost.Function的基本��?/a>
Boost.Function库用来提供一个对象化的函数指针�?br>
函数指针对设计很有用。它使调用者可以�g期调用，调用时机��p��用者确定。而且可以改变
响应者，以应对不同的要求�?br>
C中的函数指针只能用于自由函数。在C++中除了自由函数还有函数对象和�c�L��员函敎ͼ��q�些
C的函数指针是无法用的。这要求能适应C++语言的函数指针。既然C++语言本��n没有提供�Q?br>那就提供一个库。stl提供了，但是定义了很多类型，使用��h��q�不是很方便�Q�而且函数参数
的个数被限定在两个以下，更能是备受限制。Boost.Function库提供了一个好的解��x��案�?br>
Boost.Function库可以支持自由函敎ͼ�函数对象�Q�类成员函数。而且参数个数多达10个�?br>Boost.Function库利用模板技术来实现。生成的代码有很高的�q�行效率。本库可以不用编�?br>直接使用�?br>
Boost.Function的头文�g�?br>function.hpp

定义一个Boost.Function的对象（是一个返回值类型�ؓint�Q�第一个参数是std::string�c�d��
�W�二个参数是float�c�L��Q?br>
boost::function< int ( std::string, float ) > funptr;

上面�q�个定义方式是一�U�容易理解的定义方式。但有些�~�译器不支持�Q�如果想更多的编译器
支持�Q�则用下面这�U�定义方�?br>
boost::function2< int, std::string, float > funptr;

注意模板中有3个类型，而function�c�d��是boost::function2。应��回值类型不计算在参�?br>�c�d��中（原因很简单，C++的编译器不会�Ҏ��q�回�c�d��不同来区分函数定义的不同�Q��?br>
int freefun( std::string str, float f )
{
    std::cout << str << " : " << f << std::endl;
    return 0;
}

class CFun
{
public:
    int operator() ( std::string str, float f )
    {
        std::cout << str << " : " << f << std::endl;
        return 0;
    }
}

上面定义了一个自由函数和一个函数对象。下面将把他们付�l�function对象�?br>
赋��gؓ自由函数
funptr = &freefun;

赋��gؓ函数对象
CFun fun;
funptr = fun;

以上两种情况的调用方法一��_��如下
funptr( "float =", 10.0 );

Boost.Function对象要能指向�c�d��原函敎ͼ�其定义要如下

class FreeClass
{
public:
    int out( std::string str, float f )
    {
        std::cout << str << " : " << f << std::endl;
        return 0;
    }
};

boost::function< int ( FreeClass*, std::string, float ) > funptr;

跨��^台的定义�Ҏ��
boost::function3< int, FreeClass*, std::string, float > funptr;

赋值方�?br>funptr = &FreeClass::out;

调用�Ҏ��
FreeClass fc;

funptr( &fc, "float =", 10.0 );

RichardHe 2008-06-04 14:45 发表评论

RichardHe — Tue, 03 Jun 2008 03:39:00 GMT
flipcode
仿函数、绑定、桥接、委托相兌��?
以下随便讨论下，没突出的中心论点�Q�个中理论只代表我个��点，隑օ�有错:)�Q�欢�q�指正�?br>一。需�?
在事件处理常�怼��到�q�样的情况：
1。接口分��R��即invokers(调用�?�?receivers)接收者分��R�?br>2。时间分��R�?br>
比如��_��UI相关元素�Q�按钮、菜单等�Q�就是一个invokers�?br>receivers则是响应命��o的对象（如对话框或应用程序本�w�）�?br>�q�需要我们要先将UI相关元素的事件响应的接收者在初始化时先保存�v来�?br>待后用户按下按钮�{�再触发�Q�即invokers通过调用对应先前保存的receivers来执行命令）
嗯，在delphi、java、vcl�?net中有相关的实现。而vc则需要自己来弄�?br>
二。仿函数的实�?
在说仿函数前先说说我们应该怎么保存�q�些操作相关函数的呢�Q?br>// 一般的函数我们可以�q�么�?
void (*fun)() = Test;
(*fun)();
// 而类成员函数可以�q�么�?
void (CTest::*mfn)(); // 或用 typedef void (CTest::*MFN_TEST)(); MFN_TEST mfn;
mfn = CTest::Test;
CTest a, *p=new CTest;
(a.*mfn)(); // 调用�Ҏ��1
(p->*mfn)(); // 调用�Ҏ��2
如上所�q�可见�ؓ了处理前面所�q�的事�g响应情况�Q�我们通常会用回调函数�Q?br>��是把类成员函数定义为静态函敎ͼ�在初始时保存函数地址�Q�与一般函数处理类同）及对应的对象指针�Q?br>在事件触发时调用对应的静态函敎ͼ�而该函数中在把指针强制�{化�ؓ对应�c�d��对象地址�Q?br>得以操纵该对象的成员变量(嗯，理论上跟成员函数的实现差不多�Q�成员函��C��q��译器安插一�?br>this指针作�ؓ�W?个参��C��l�函敎ͼ�以便可以操作该this对象的成�?�?br>
回调函数应用的具体代码如�?
1). 回调接口(静态函数法):
//======================================================
#include "stdafx.h"
#include

typedef void(*KEY_RESPOND)(void* /*,param*/);
struct CListener
{
void* pThis;
KEY_RESPOND pfn;
CListener() : pThis(0), pfn(0){}
};
class CInput
{
std::list m_listListener;
public:
void AddListener( CListener* pListener ){
m_listListener.push_back( pListener );
}
void RemoveListerner( CListener* pListener ){
std::list::iterator iter;
for( iter = m_listListener.begin(); iter!= m_listListener.end();iter++ ){
if( pListener == (*iter) ){
m_listListener.erase( iter ); break;
}
}
}
void HitOneKey(){
std::list::iterator iter;
for( iter = m_listListener.begin(); iter!= m_listListener.end();iter++ ){
if( (*iter)->pfn && (*iter)->pThis ){
(*(*iter)->pfn)( (*iter)->pThis );
}
}
}
void clearListener(){
m_listListener.clear();
}
};
class CUI
{
public:
static void InputProc(void* pThis/*,param*/){
__asm int 3 // 下个断点��试下（某些�~�译器不能这么写�Q�vc可以�Q?br>}
};

CUI ui;
CInput input;
int _tmain(int argc, _TCHAR* argv[])
{
// 初始:
CListener* pListener = new CListener;
pListener->pfn = &CUI::InputProc;
pListener->pThis = &ui;
// 触发:
input.AddListener( pListener ); // input即�ؓinvokers�Q�调用者，但叫触发者好点）
input.HitOneKey(); // 某处事�g触发,内部呼叫receivers(�q�里是原先保存的CUI对象)来真正处理该事�g(InputProc(...)�Ҏ��)�?br>// 清除
input.clearListener();
if( pListener )
{
delete pListener;
pListener = NULL;
}
return 0;
}
//======================================================

// �W?�U�方�? 回调�c?虚函数多态法):
//======================================================
class IWillBack
{
public:
virtual void InputProc(/*参数�?..*/){}
};
class CInput
{
public:
void RegisterListener(IWillBack* pListener){
m_pListener = pListener; // �q�里用list存�v来才好，�q�里只作��试
}
void OnInputEvent(){
m_pListener->InputProc(/*参数�?..*/);
}

private:
IWillBack* m_pListener;
};
class CUI : public IWillBack
{
public:
void InputProc(/*参数�?..*/){ /*..实际处理代码..*/}
private:
};

int _tmain(int argc, _TCHAR* argv[])
{
CInput aa;
CUI bb;
aa.RegisterListener(&bb);
aa.OnInputEvent();
return 0;
}
//======================================================

但是�W?�U�静态函数用法是不直观的�Q�第2�U�需要派生增加了之间的联�p�，而�ؓ了方便我们通常会将成员函数指针转化为函数对象来处理,即仿函数(一般是指重载了()操作�W�的�c?来实现�?br>
�c�M��于这��L��操作�Q�stl提供了mem_fun、mem_fun_ref、binder1st、binder2nd��单操作�?br>但stl的方法相�Ҏ��较原始而受限制�Q�比如说std::mem_fun需要成员函数有�q�回�?
std::mem_fun最多只能支持成员函数有一个参数等�Q?br>下面来看std:mem_fun_ref不支持成员函数返回��gؓvoid的一个例�?
//======================================================
#include
class CFoo
{
public:
void test() // 只有��void�Ҏ��别的�c�d��才可以，�?int
{
return 0;
}
};
void main()
{
CFoo t;
std::mem_fun_ref(&CFoo::test)(t);
}
//======================================================
上述代码只有��void�Ҏ��别的�c�d��Q�如int�Q�才可以�Q?br>那么��Z��么不可以处理�q�回void的函数呢? stl的实现究竟是怎么��L��?
嗯，stl��单实��C��mem_fun_ref及mem_fun,其中mem_fun_ref以引用方式处理函数所属对象，
而mem_fun以指针方式处理函数所属对象�?br>现在让我们从vc的stl挖出部䆾代码来看看，

1.stl的实�?
以mem_fun_ref��Z��(省略某些对说明不重要的细节，两条虚线包括的代码�ؓstl�c�M��源码):
//======================================================
//----------------------------------------------------------
namespace stl_test
{
// 主要实现:
template
class mem_fun_ref_t
{
public:
mem_fun_ref_t( R (T::*_Pm)() ) : _Ptr(_Pm) {} // 构�? 保存成员函数地址
R operator()(T& _X) const // 调用: �q�里可看出mem_fun_ref以引用方式处�?br>{
return ((_X.*_Ptr)()); // �q�里执行调用函数�Q��ƈ�q�回该函数所�q�回�?br>}
private:
R (T::*_Ptr)(); // 指向成员函数地址的指�?br>};
// �q�里只是利用函数的参数推导来自动获取型别(方便调用)
template inline
mem_fun_ref_t mem_fun_ref(R (T::*_Pm)())
{
return (mem_fun_ref_t(_Pm));
}

} // end of namespace test_stl
//----------------------------------------------------------
class CFoo
{
public:
int test1(){
__asm int 3
return 0;
}
void test2(){
__asm int 3
}
};
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
CFoo t;
stl_test::mem_fun_ref( &CFoo::test1 ) (t);
return 0;
}
//======================================================
/////////////////////////////////////////////////////////////////
从源�?return ((_X.*_Ptr)()); " 可以看到stl直接�q�回该函数所�q�回倹{�?br>所以函数没有返回��|��即�ؓvoid�Ӟ��的话�~�译器就会报错。好�Q�那么如果我们在
�q�里只是直接执行函数而不用return�q�回的话�~�译器应该可以通过了�?br>
嗯，boost中正是这么处理的。（btw.��Z��更�ؓ通用�Q�boost对stl原有仿函数及�l�定作了大量的改�q�工作）�?br>但是具体应该怎么区分有没有返回值呢�Q�这个也�Ҏ��Q�我们只需用到模板的偏�Ҏ��就�?br>以做到。下面就看看boost的实�?btw.boost有两�U�版本，我用的是兼容版本�Q�代码难�?

2. boost的实�?�q�里我把boost的一大堆宏（真@$@#@#隄��Q�loki在这斚w��来得比较清爽�Q�去掉了):
/////////////////////////////////////////////////////////////////
// notreturn.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
//------------------------------------
namespace boost_test
{
template // 有返回值时会调用这�?br>struct mf
{
template
class inner_mf0
{
R (T::*_Ptr)();
public:
inner_mf0(R (T::*f)()) : _Ptr(f) {}
R operator()(T& X) const
{
return ((X.*_Ptr)());
}
};
};
template<> // 没有反回值时会调用这�?br>struct mf // 偏特�?br>{
template
class inner_mf0
{
R (T::*_Ptr)();
public:
inner_mf0(R (T::*f)()) : _Ptr(f) {}
R operator()(T& X) const
{
((X.*_Ptr)());
}
};
};
// 创徏一�z��c?�z��于上�q�基�c?br>template
struct mf0 : public mf::inner_mf0
{
typedef R(T::*F)();
explicit mf0(F f) : mf::inner_mf0(f) {}
};
// 通过函数的参数推��D��动获取类�?br>template
mf0 mem_fn( R(T::*f)() )
{
return mf0(f);
}
} // namespace boost_test
//------------------------------------

class CFoo
{
public:
int test1(){ return 0; }
void test2(){}
};
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
CFoo t;
boost_test::mem_fn( &CFoo::test1 ) (t);
return 0;
}
/////////////////////////////////////////////////////////////////

从上�q�C��码可以看到偏�Ҏ��帮助我们解决了�q�回��gؓvoid的情��c��但是手写了两䆾
基本相同的代码。。�?br>另外处理参数个数的情况也很容易，只要分别实现不同参数的各个模板类��可以了�Q?br>boost最多只能支持成员函数有8个参敎ͼ�因�ؓ它内部实��C��8份这样不同参数模板类�?br>其实的处理方法都是一模一��L��Q�可是由于语�a�的限制我们还是没有办法不一一实现
不同参数的类:。在loki中参数可以用TList实现��L��的参敎ͼ�但是在实现还是得�?br>老实实的每䆾手写一份（loki实现�?5份可以支�?5个参敎ͼ��?br>�q�真让�h郁闷。。。不�q�没办法�?br>
说完来仿函数�Q�下面开始说说有关绑定，stl、boost、loki的绑定的意思是
�Ҏ��物实体的“�l�定”�Q�通俗来说是指对函数、构造函数、仿函数�{�与其对应的某个参数的绑定，
以便在调用时不用再次输入此参敎ͼ�因�ؓ某些时候参数是固定的，比如说绑定一个内部存�?br>成员函数地址的仿函数和它对应的对象地址在一��P��?br>以下是stl的bind用法:
//================================
#include "stdafx.h"
#include // stl
#include // boost

struct CFoo {
int test(int){
return 0;
}
};
void main()
{
boost::function1 f; // �q�里用了boost
CFoo obj;
f = std::bind1st(std::mem_fun(&CFoo::test), &obj);
f(5);
}
//================================
loki中的BindFirst比较�c�M��于stl的binder
(binder1st�Q�binder2nd)�Q�但是它是通用的，可以通过嵌套实现��L��多个参数�l�定�Q?br>//================================
void f()
{
Functor cmd1(something);
Functor cmd2(BindFirst(cmd1, 10));
cmd2(20);
Functor cmd3(BindFirst(cmd2, 30));
cmd3();
}

而boost中的实现是以占位�W�来表现,具体如何实现�Q�下回��l�讨�?嗯，
boost代码的宏太多了，�q�部份还是等有空再补全了�Q�现在我们来看看如何实现一个委托类)

三。委托类的实�?
1. 桥接模式:
设计模式告诉我们可以使用桥接模式(Bridge Pattern)减少对象之间�?耦合度，桥接模式如下:
Invoker <>------------------->* Interface
^
|
Receiver
上图的Invoker表示事�g触发者，Receiver表示事�g处理者，�W�号�c�M��于＜c++大规模编�E�。。＞一书所描述�Q�注�Q�这里符号对位可能出错：变成左对齐了�Q�，
其中<>------------------->表示Invoker 内含(拥用)Interface(即Invoker 有Interface的变量或指针�q�负责Interface的释�?�Q?br>�?可��C�可有多个�?br>^
| 　号则表示�l�承于（Receiver�l�承于Interface�Q��?br>
好，我们先来分析前面�? �W?�U�方�? 回调�c?虚函数多态法):"的实现思想(请回到前面看看代�?�Q?br>它其实就是一个桥接模式，如下(括号内对应前面所实现的类)�Q?br>Invoker(CInput) <>--------------->* Interface�Q�IWillBack�Q?br>^
|
Receiver�Q�CUI�Q?br>对照我们前面实现的代码可以发现此�U�实现的桥接的缺�Ҏ��Q�每一个想�?br>注册一�Ҏ��到Invoker中以便Invoker在事件触发时调用的类(如Receiver)都要�z��自Interface�?br>有没有更好的办法再次减少�q�种耦合度呢�Q�这正是下面我们要讨
论的下一�U�设计模式：
2. 委托与事�?
委托的处理设计如�?
Invoker <>--------------------->* Interface
^
|
Implementation -----------------> Receiver
卛_��原桥接模式下再加一层间接�?Implementation 。其�?br>Implementation与Receiver之间�?---------------->表示Implementation引用了Receiver一些服务，
即Implementation用到了Receiver某些东西�Q�如函数或数据）。嗯�Q�这些解释不知是否适当�Q�希望不会误对{��。�?br>好，一开始可能我们会�q�么设计:
//======================================================================================
class handle {};
template
class Implementation : public handle
{
T* m_pThis;
public:
Implementation ( T* pThis ) : m_pThis(pThis) {}
template
void execute( void (T::*mfn)(T1), T1 arg ) { (m_pThis->*mfn)( arg ); }

};
struct Receive {
void Proc(int) {
__asm int 3
}
};
Receive a;
void Invoker(){
Implementation test = Implementation (&a);
test.execute( Receive::Proc, 10 ); // 当事件发生时调用
};
int _tmain(int argc, _TCHAR* argv[])
{
Invoker();
}
//======================================================================================
但是Invoker知道了太多Receive的信息，况且我们惌��触发者Invoker作成一个类�?br>一个改�q�的版本如下:
//-------------------------------------------------------------
// signal slot system
// �? 该法我是看了"落木随风"�?委托、信号和消息反馈的模板实现技�?�Q?br>// 代码作了部䆾��d��。在�q�里非常的感谢他!
// 他的博客�Q�http://blogs.gcomputing.com/rocwood/archives/000154.html
//-------------------------------------------------------------
// Delegation.cpp : Defines the entry point for the console application.
//
#include

#ifndef K_DELEGATE_H
#define K_DELEGATE_H

namespace kUTIL
{
// 1. 桥接�c?�U�虚�c?:
// ��Z��么叫作桥�?
// 因�ؓ通过它的虚函数方法可以调用到对应的正��的不同�z��实例(指后�?br>// 提到的委托�h)所改写的虚函数�Ҏ��(�q�是委托人用来完成委托�Q务的�Ҏ��)
struct kDelegationInterface
{
virtual ~kDelegationInterface() {};
virtual void Execute() = 0;
};
// 2. 委托�c?�z��于桥接类�Q�这里我叫�ؓ”委托�?#8220;)
// ��Z��么叫委托�Q?br>// 因�ؓ调用者把“通知”的工作委托给它来负责处理�?br>// 一�?#8220;委托�?#8221;保存�? a.”接收�?#8220;(对象指针m_pThis) �?b.“要作的事”(�Ҏ��指针m_mfn)�Q?br>// 以便调用者发��Z��号弹(后面提到,信号�Ҏ��一个作桥接用的�U�虚�cȝ��指针指向相应的委托�h)
// 告知此信号对应的委托人来完成它被委托的工作：卌��“接收�?#8221;(m_pThis)�?#8221;要作的事“(m_mfn)�?br>template
struct kDelegationImpl : public kDelegationInterface
{
typedef void ( T::* MFN )();
kDelegationImpl( T* pthis, MFN mfn ) : m_pThis( pthis ), m_mfn( mfn ) {
}
virtual void Execute() {
if( m_pThis ) {
( m_pThis->*m_mfn )();
}
}
T* m_pThis;
MFN m_mfn;
};

// 3. 信号�?实现��Z��函数来调用统一的虚函数接口):
// ��Z��么叫信号�Q?br>// 因�ؓ�?信号�?发射�?调用信号的操作符"()")
// 它会通知所指向�?委托�?事�g发生�?调用�U�虚�c�L��针的m_DI->Execute()�Ҏ��)�?br>// 一个信号保存了一个指向对�?#8221;委托�?#8220;的桥接类(�U�虚�c?指针�?br>struct kSignal0
{
kDelegationInterface* m_DI; // �U�虚�cȝ��指针
kSignal0() : m_DI(0) {}
// 1. �U�虚�cȝ��m_DI指针可以指向不同的派生实�?
template
void ConnectSlot(T* recv, void (T::* mfn)()) {
DisConnect();
m_DI = new kDelegationImpl( recv, mfn );
int test = 0;
}
void DisConnect() {
if( m_DI ) { delete m_DI; m_DI = NULL; }
}
// 2. 用统一的纯虚类指针调用不同�z��c�L��写的虚函�?br>void operator() () {
if( m_DI ) {
m_DI->Execute();
}
}
};

// 下面是两个�ؓ方便使用的函�?
template
void kConnect( kSignal0& sgn, T* pObj, void(T::*fn)())
{
sgn.ConnectSlot( pObj, fn );
int i = 0;
}
inline void kDisConnect( kSignal0& sgn )
{
sgn.DisConnect();
}
} // end of namespace kUTIL
#endif //#ifndef K_DELEGATE_H

//----------------------------------------------------------------------------
// 一个��用实�?
class kButton {
public:
kUTIL::kSignal0 sgnMouseBtnUp;
void OnMouseButtonUp() { sgnMouseBtnUp(); }
};

class kDialog {
kButton btn;
public:
kDialog() {
kUTIL::kConnect( btn.sgnMouseBtnUp, this, &kDialog::DoWork ); // vc6下这里kDialog::DoWork的前面一定要可加"&"�?br>}
void DoWork() {
__asm int 3
}
void TestMouseHit() { btn.OnMouseButtonUp(); }
};

int main(int argc, char* argv[])
{
kDialog dlg;
kButton btn;
kUTIL::kConnect( btn.sgnMouseBtnUp, &dlg, kDialog::DoWork ); // vc6下这里kDialog::DoWork的前面可�?不加"&"�?br>
// ��试一:
btn.OnMouseButtonUp();

// ��试�?
dlg.TestMouseHit();
return 0;
}

// 委托实例�ȝ��Q?br>// 下面我们来具体说�?#8221;当某事发生时�Q�调用者发��信号弹通知对应的接收者作相应处理“
// 1. "调用�? 拥有各种信号式V�?br>// 2. 初始�Ӟ��我们把信号弹与对应的委托��p��v来，�q�让委托��录在信号触发时应该通知�?接收�?�?接收��作的�?�?br>// a. 信号弹保存了�?�U�虚�c?指针�Q�指针指向通过其模板函数ConnectSlot�Ҏ��来找�?产生�?委托�?委托实例)�?br>// b. 委托�?委托实例)在信号弹用ConnectSlot�Ҏ��产生它的时候保存了函数ConnectSlot所传入的两个参敎ͼ�
// �?接收者指�?�?其方法指�?�?br>// 3. 当事件发生时"调用�?发射对应信号弹后�Q�信号弹会调用其所保存的纯虚类指针的虚函数�Ҏ��Q?br>// 于是�׃��虚函数特性就会调用到其所指向的委托实�?委托�?所改写的方法�?br>// 5. 委托人改写的�Ҏ��中通过其所保存�?#8221;接收者指�?#8220;及其"�Ҏ��指针"来呼�?接收�?用对应的”�Ҏ��指针“
// 来处理事情�?br>// 卛_��下流�E?
// "调用�?发射"信号�? ---> "信号�?通过"�?扑ֈ�对应"委托�? ---> "委托�?呼叫"接收�?�?该作的事"

//=============================================================================
嗯，�q�样到此�Q�一个非常方便的委托�c�d��得以实现了！如果你还不懂的话请仔�l�的琢磨�Q�如此精�?因�ؓ��单而强�?
不要错过。不�q�上�q�只是部份实玎ͼ�当你要支持带参数及返回值的各种情况的话�Q�还得自�׃��扩充�?br>�q�回值的处理�Ҏ��可参见前面剖�q�boost的mem_fn的处理方法，而带不同参数的处理则只能一一手动
实现�Q�就象前面所说的那样�Q�这是很无奈的事情，但是目前来说没有办法。。�?br>
(待箋。。。。。�?如果有时间有必要的话。。�?

�?
loki下蝲:
http://sourceforge.net/projects/loki-lib/

boost下蝲:
http://sourceforge.net/projects/boost/

2004.10.26更新�Q?br>修正:
原void connect( Signal0& sgn,T1 obj, void(T2::*fn)())�Ҏ��
void connect( Signal0& sgn,T1& obj, void(T2::*fn)())
另外加了kDisConnect释放内存�Q�原来只作测试没写它�Q�现在还是加上了�?br>
--------------------------------------------------------------------------------

千里马肝
实在是太好了

PS�Q�阳春的东西�Q�就会曲高合寡�?:D

--------------------------------------------------------------------------------

flipcode
好久没上�|�了�Q?br>今天上来看到版主的夸奖，
虽然是过奖了�Q�不�q�还是感觉轻飘飘的。。。嘿嘿~~~�Q?:D

--------------------------------------------------------------------------------

kane
嗯，�q�种技巧是比较实用的�?img src ="http://www.shnenglu.com/richardhe/aggbug/52015.html" width = "1" height = "1" />

RichardHe 2008-06-03 11:39 发表评论

RichardHe — Fri, 16 May 2008 09:44:00 GMT
转自http://www.shnenglu.com/alantop/archive/2008/05/15/49989.html
char test[] = "0xf";
long lResult = strtol(test, '\0', 16);

RichardHe 2008-05-16 17:44 发表评论

callback function

RichardHe — Thu, 15 May 2008 06:54:00 GMT

声明函数指针

回调函数是一个程序员不能昑ּ�调用的函敎ͼ�通过��回调函数的地址传给调用者从而实现调用。要实现回调�Q�必��首先定义函数指针。尽��定义的语法有点不可思议�Q�但如果你熟悉函数声明的一般方法，便会发现函数指针的声明与函数声明非常�c�M��。请看下面的例子�Q?br>
void f()�Q?/ 函数原型

上面的语句声明了一个函敎ͼ�没有输入参数�q�返回void。那么函数指针的声明�Ҏ��如下�Q?br>
void (*) ();

让我们来分析一下，左边圆括弧中的星��h��函数指针声明的关键。另外两个元素是函数的返回类型（void�Q�和��p��圆括弧中的入口参敎ͼ�本例中参数是�I�）。注意本例中�q�没有创建指针变�?只是声明了变量类型。目前可以用�q�个变量�c�d��来创建类型定义名及用sizeof表达式获得函数指针的大小�Q?br>
// 获得函数指针的大��?br>unsigned psize = sizeof (void (*) ());

// 为函数指针声明类型定�?br>typedef void (*pfv) ();

pfv是一个函数指针，它指向的函数没有输入参数�Q�返回类行�ؓvoid。��用这个类型定义名可以隐藏复杂的函数指针语法�?br>
指针变量应该有一个变量名�Q?br>
void (*p) (); //p是指向某函数的指�?br>
p是指向某函数的指针，该函数无输入参数�Q�返回值的�c�d��为void。左边圆括弧里星号后的就是指针变量名。有了指针变量便可以赋��|��值的内容是��v名匹配的函数名和�q�回�c�d��。例如：

void func()
{
/* do something */
}
p = func;

p的赋值可以不同，但一定要是函数的地址�Q��ƈ且��v名和�q�回�c�d��相同�?br>
传递回调函数的地址�l�调用�?br>
现在可以��p传递给另一个函敎ͼ�调用者）- caller()�Q�它��调用p指向的函敎ͼ�而此函数名是未知的：

void caller(void(*ptr)())
{
ptr(); /* 调用ptr指向的函�?*/
}
void func();
int main()
{
p = func;
caller(p); /* 传递函数地址到调用�?*/
}

如果赋了不同的值给p�Q�不同函数地址�Q�，那么调用者将调用不同地址的函数。赋值可以发生在�q�行�Ӟ��q�样使你能实现动态绑定�?br>
调用规范

到目前�ؓ止，我们只讨��Z��函数指针及回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几�U�调用规范。如在Visual C++中，可以在函数类型前加_cdecl�Q�_stdcall或者_pascal来表�C�其调用规范�Q�默认�ؓ_cdecl�Q�。C++ Builder也支持_fastcall调用规范。调用规范媄响编译器产生的给定函数名�Q�参��C��递的��序�Q�从叛_��左或从左到右�Q�，堆栈清理责�Q�Q�调用者或者被调用者）以及参数传递机�Ӟ��堆栈�Q�CPU寄存器等�Q��?br>
��调用规范看成是函数�c�d��的一部分是很重要的；不能用不兼容的调用规范将地址赋值给函数指针。例如：

// 被调用函数是以int为参敎ͼ�以int��回�?br>__stdcall int callee(int);

// 调用函数以函数指针�ؓ参数
void caller( __cdecl int(*ptr)(int));

// 在p中企囑֭�储被调用函数地址的非法操�?br>__cdecl int(*p)(int) = callee; // 出错

指针p和callee()的类型不兼容�Q�因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针p�Q�尽��两者有相同的返回值和参数列�?br>

RichardHe 2008-05-15 14:54 发表评论

RichardHe — Wed, 14 May 2008 09:53:00 GMT

《设计模式精解》读书笔�?<�?gt;http://www.cnblogs.com/lzcarl/archive/2005/09/01/228281.html

1、模式是应该�l�合在一起共同解决问题的�?/span>

评论�Q�以前看�?/span>GOF设计模式》的时候主要就是看目的�Q�然后就是代码，对协作啊�Q�优�~�点啊，效果啊都不怎么注意�Q�不�q�就��看了也不知所云。学下来��像背数学公式一��P��单个是记住了�Q�拿到具体环境里又懵了。看来还是得多花�Ҏ��间看看模式的兌��啊�?/span>

2、我的错误是�Q�我��试先创建问题领域中的篏�Q�然后将�q�些�cȝ��合�v来�Ş成最�l�的�pȝ��。—�?/span>Alexander把这��L��q�程�U�Cؓ一�?#8220;坏主�?#8221;。我从来没有问过我自己：我是否拥有正��的�c�？仅仅因�ؓ�q�些�cȝ��h��如此正确、如此明显。我拥有的是在开始分析时立刻�q�入脑�v中的�c�，是我们的老师告诉我们应该在系�l�中��L��?#8220;名词”。但是我的错误就是仅仅尝试把它们��单地攑֜�一赗��?/span>

评论�Q�连大牛都会犯这��L��错误�Q�我�q�样的菜鸟这样分析系�l�应该也比较正常吧。在看问题的层次上，我们太过于重视细节，��像我写WinForm�E�序时先考虑有哪些组件可以��用一��P��把思�\�l�限制住了，忽视了类所处的环境、上下文�?/span>

3、面向对象的范式�Q��用对象将责�Q转义到更局部的范围。对象应该对自己负责�Q��ƈ且这�U�责��d��该被清楚的定义出来�?/span>

评论�Q�这个对�cȝ��定义��p��合理的多。作者认��Y件开发中有三个视角：概念�Q�用例）�Q?/span>>规格�Q�接口）�Q?/span>>实现�Q�代码）。从最低层�ơ看�Q�类��是变量+函数�Q�但�q�样��太狭隘了。真正的对象应该与现实生�z�M��的对象相��|��有自��q��行�ؓ、状态，自己对自��p��?/strong>�Q�多么精��的概述啊）�?/span>

4、抽象类��是其他�cȝ��占位�W��?/span>

评论�Q�比较�Ş象的描述。我先描�q�类的大致行��Z��调用者了解，具体的行为留到子�c�d��玎ͼ�抽象�c�M��子类达成一个契�U��?/span>

5、过早的对细节投入过多的兛_��是一个分析缺陗��?/span>

评论�Q�同2�?/span>

6、留意你的直观：当你看到某些不喜�Ƣ的东西�Ӟ��你胃部的感觉�?/span>

评论�Q�牛人就是幽默。这里主要是说明如何感觉一个设计是坏的设计的。我是说最�q�写�E�序胃老不舒服�Q�饭也吃不好……

7、关注模式的场景而非解决�Ҏ��?/span>

评论�Q�作者自始至�l�一直强调是场景军_��解决�Ҏ��Q�而不是�ؓ了实现某个模式而去�q�行设计�Q�否则就像小学生套公式一样了。场景分析好了，模式自然也就出来了（�q�是境界比较高的时候）�?/span>

8、在创徏对象时用共同�?/span>/变化点分析而非观察名词与动词。因此，我们要：

   a、发现�ƈ��装变化炏V�?/span>

   b、优先��用对象组合，而非�cȝ��ѝ�?/span>

评论�Q�关于共同点/变化点的分析�Q�在Bridge模式中体现的犹�ؓ明显�Q�我在前面的Blog中介�l�过�Q�，借助分析矩阵也可以帮助理清思�\。�?/span>b�Ҏ��面向对象设计中的基本原则�Q�就不用多说了�?/span>

9�?/span>switch语句常常标志着�Q�（1�Q�对多态行为的需要。（2�Q�存在着��N��地方的责仅R��请考虑用一�U�更普适的解决�Ҏ��代替switch语句�Q�比如抽象、将责�Q分配�l�另外的对象�{�等�?/span>

评论�Q�老听别�h说丑陋的switch语句�?/span>ifelse语句�Q�都不是太懂�Q�现在好像有�Ҏ��了，因�ؓ条�g语句不灵�z�，很难�l�护吧。碰到它马上��p��惛_��用多态的方式��d��理，�?/span>State模式�?/span>Visitor模式��和�q�有兟�?/span>

10、用模式的方法去思考：

步骤�Q?/span>

�Q?/span>1�Q�、发现我在问题领域中拥有的模�?/span>

�Q?/span>2�Q�、对于这些需要分析的模式�Q�做下列工作�Q?/span>

   a、挑��Zؓ其他模式提供最多场景的模式�?/span>

   b、在我概忉|��最高的设计中��用这个模式�?/span>

   c、识别�Q何可能已�l�出现的附加模式。将它们��d��?#8220;需要分析的模式”中�?/span>

   d、对需要分析而未分析的模式，重复上述工作�?/span>

�Q?/span>3�Q�、按照需要将�l�节��d��的设计中。扩展方法和�c�d��义�?/span>

评论�Q�具体的说就是找到可以统领全局的模式，再用其他的模式配合它�Q?#8220;面向模式的设�?#8221;(POP)。算了吧�Q�我�q?/span>OOP都没学好�Q�这个以后再说啦�?/span>

11、在学习面向对象技术的早期学习设计模式�Q�可以大大帮助你提高寚w��向对象分析、设计的理解�?/span>

评论�Q�这个倒是�W�一�ơ听��_��不过怎么也得先把�l�承、封装、多态弄清楚吧。再加上一条，在学习设计模式时�Q�一定要先读�q�本《设计模式精解》，再看�?/span>GOF设计模式》，�?/span>

RichardHe 2008-05-14 17:53 发表评论

OOD原则�Q�SRP、OCP以及LSP

RichardHe — Wed, 14 May 2008 05:21:00 GMT

单一职责原则�Q�SRP : Single Response Principle)

��׃��个类而言�Q�应该仅有一个引起它变化的原因�?br>在这里，职责的定义是�Q? “变化的原�?#8221;�?/font>

对于何时遵��@SRP有以下的考虑�Q?br>1.如果应用�E�序的变化会影响到类中某一�U�职责，那么��应该将它与另一�U�职责分开�Q�这样做可以避免客户应用�E�序和类中的�q�两职责耦合在一赗��?br>2.如果应用�E�序的变化��L��会导致两个职责同时变化，那么��׃��必要分离它们。实际上�Q�分��d��们会引�v不必要的复杂性�?br>
从上可以得知�Q�变化的轴线仅当变化实际发生时才��h��真正的意义。如果没有征兆，那么��d��用SRP�Q�或者�Q何其它原则都是不明智�?br>
实际应用�Q�持久化�Q�Persistence�Q?/strong>
�? 际开发中�Q�考虑��C��务规则是会频�J�改变的�Q�而持久化的方式却不会如此频繁的变化，�q�且变化的原因也是完全不同的。如果把业务规则和持久化方式�l�定��C��P�� ׃��Z��后的开发、维护造成�ȝ��。运用分层（layer�Q�架构模式或者TDD开发方式可以很早分��这两个职责�Q�特�D�情况下�Q�还可以使用FACADE或�? PROXY模式对设计进行重构，分离�q�两个职责�?br>

开闭原则（OCP : The Open-Close Principle)

描述�Q��Y件实体（�c�R��模型、函数等�{�）应该是可以扩展的�Q�但是不可修攏V�?br>
遵��@开闭原则设计出的模块具有两个主要的特征。它们是�Q?br>1. “对于扩展是开攄��”�Q�Open for extension�Q��?br>   �q�意味着模块的行为是可以扩展的。当应用的需要改变时�Q�我们可以对模块�q�行扩展�Q��其具有满��那些改变的新行为。换句话��_��我们可以改变模块的功能�?br>2. “对于更改是封闭的”�Q�Closed for modification�Q��?br>   �Ҏ��块行��行扩展时�Q�不必改动模块的源代码或者二�q�制代码。模块的二进制可执行版本�Q�无论是可链接的库、DLL或者Java�?jar文�g�Q�都无需改动�?br>
对于OCP�Q�关键的�? 抽象
模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，所以它对于更改可以是关闭的。同�Ӟ��通过从这个抽象体�z��Q�也可以扩展此模块的行�ؓ�?br>
在许多方面，OCP都是面向对象设计的核心所在。但实际应用中，滥用OCP原则也是错误的。正��的做法是应该仅仅对�E�序中呈现出频繁变化的那些部分做出抽象。拒�l�不成熟的抽象和抽象本��n一样重要�?/div>

Liskov替换原则�Q�LSP�Q?/font>

描述�Q�子�c�d��Q�subtype�Q�必��能够替换掉它们的基�c�d��Q�base type�Q��?br>
此原则是Barbara Liskov首次�?988�q�写下的。所以就叫做Liskov替换原则。她如此写到�Q?br>“�q�里需要如下替换性质�Q�若�Ҏ��个类型S的对象o1�Q�都存在一个类型T的对象o2�Q��得在所有针对T�~�写的程序P中，用o1替换o2后，�E�序P行�ؓ功能不变�Q�则S是T的子�c�d��?br>
LSP然我们得��Z��个非帔R��要的�l�论�Q�一个模型，如果孤立的看�Q��ƈ不具有真正意义上的有效性。模型的有效性只能通过它的客户�E�序来表现�?br>
在考虑一个特定设计是否恰当时�Q�不能完全孤立的来看�q�个解决�Ҏ��。必��要�Ҏ��该设计的使用者所做出的合理假设来审视它�?br>
�? 谁知道设计的使用者会做出什么样的合理假讑֑��Q�大多数�q�样的假��N��很难预测。事实上�Q�如果试囑֎�预测所有这些假设，我们所得到的系�l�很可能会充满不必要�? 复杂性的臭味。因此，像所有其它原则一样了�Q�通常最好的办法��是只预��那些最明显的对于LSP的违反情况，而推�q�所有其它的预测�Q�直到出现相关的脆弱性的臭味�Ӟ��才去处理它们�?br>
IS-A是关于行为的�?/font>
LSP清晰的指出，OOD中IS�Q�A关系是就行�ؓ方式而言的，行�ؓ方式是可以进行合理假讄��Q�是客户�E�序所依赖的�?br>
��Z��契约设计
�? 于契�U�设计（DBC�Q�Design By Contract�Q�。��用DBC�Q�类的编写者能够显式的规定针对该类的契�U�。客户代码的�~�写者可以通过该契�U�获悉可以依赖的行�ؓ方式。契�U�是通过为每个方法声明的前置条�g�Q�preconditions)和后�|�条�Ӟ��postconditions)来指定的。要使一个方法得以执行，前置条�g必须要�ؓ真。执�? 完毕后，该方法要保证后置条�g为真�?br>
在单元测试中指定契约
也可以通过�~�写单元��试的方式来指定契约。客户代码编写者会��L��看这些单元测试，�q�样他们��可以知道对于要使用的类�Q�应该做什么合理的假设�?br>
启发式规则和习惯用法

1.�z��c�M��的退化函�?br> 在基�c�M��实现了f()�Ҏ��Q�在�z��c�M��的函数f()��是退化的�Q�派生类中的退化函数�ƈ不总表�C�Zؓ�q�反LSP�Q�但是当存在�q�种情况�Ӟ��q�是值得注意一下的�?br>2.从派生类中抛出异�?br> 在派生类的方法中��d��了其基类不会抛出的异常。如果基�cȝ��使用者不期望�q�些异常�Q�那么把它们��d��到派生类的方法中��׃��D��不可替换性。此时要遵��@LSP�Q�要么就必须改变使用者的期望�Q�要么派生类��׃��应该抛出�q�些异常�?br>
�? �l�：OCP是OOD中很多原则的核心。如果这个原则应用的有效�Q�应用程序就会具有更多的可维护性、可重用性以及健壮性。LSP是��OCP成�ؓ可能的主要原则之一。正是子�c�d��的可替换性才使得使用基类�c�d��的模块在无需修改的情况下��可以扩展。这�U�可替换性必��L��开发�h员可以隐式依赖的。因此，如果没有昑ּ��? 强制基类�c�d��的契�U�，那么代码��必��良好的�q�且明显的表辑և��q�一炏V�?br>      术语IS-A的含义过于广泛以至于不能作�ؓ子类型的定义。子�c�d��的正��定义是“可替换�?#8221;�Q�这里的可替换性可以通过昑ּ�或者隐式的契约来定义�?/div>

作者Blog�Q?/strong>http://blog.csdn.net/nirvana_li/

RichardHe 2008-05-14 13:21 发表评论

理解: 面向对象的设计原则与设计模式

RichardHe — Wed, 14 May 2008 02:37:00 GMT
来自http://www.shnenglu.com/cool-liangbing/archive/2008/05/13/49729.html
记得2004�q�刚接触设计模式�Q�买了经典的<<设计模式>>一书，�l�细地阅读，然后在开发中模仿。一两年旉��q�去�Q�对23�U�设�? 模式弄得�q�算比较熟悉�Q�也在��Y件设计中能用则用�Q�比如Singleton, template method, proxy, facade�{�等。但��L��觉用的不爽，当时也说不出原因�Q�就是感觉在使用的过�E�中�Q�是一�U��ؓ了��用设计模式而��用上他们�Q�有时候是生搬��套。��M��Q�自己当时是搞不清楚��Z��么要使用设计模式�Q�停留在别�h说它牛，我就学着用而不落�h之后�?
    我不是一个天质聪颖的人，对��Y件设计的理解�Q�基本上无法评自��p��力单独领悟出来。只有常常督促自己多买国内外软�g专家写的好书�Q�来学习他们在这些方面的发现和�ȝ��。靠后天学习来��I补先天不��I��也是没有办法中的办法�?br>    �l�于�?007�q�看��C��<�Q? 书中对设计模式的讨论�Q��ƈ没有特别吸引我的地方�Q�不�q�是用java语言来详�l�讲�?3�U�模式而已�Q�最多增加一些变体。深深吸引我的是"�W�二部分面向对象的设计原�?�Q? �q�一部分虽然��幅不多�Q�但清晰地说明了我们��Z��么要用设计模式，使用设计模式是来解决什么问题的�Q��用之后我们要辑ֈ�什么效果。��Y件的生命周期让我们认�? 刎ͼ�面向对象的设计要解决的核心问题是可维护性和可复用性，特别是可�l�护性，一个好软�g的维护成本远�q�大于初期开发成本�?br>    一个��Y件设计的可维护性很差，原因在于�Q�过于僵��、过于脆弱、复用率低、黏度过高。相反，一个好的系�l�设计应该是可扩展的、灵�zȝ��、可插入的。在软�g发达国家如美国，一些��Y件界的高手，�?0世纪80~90�q�代�Q�就陆箋提出一些设计原则，�q�些设计原则是在提高一个系�l�的可维护性的同时�Q�提高系�l�的可复用�? 的指导原则：
    1、开闭原则：软�g架构应该是对扩展开发，对修改关�?br>    2、Liskov替换原则�Q��Q何基�c�d��以出现的地方�Q�子�c�M��定可以出�?br>    3、依赖倒�{原则�Q�要依赖于抽象，不要依赖于实�?br>    4、接口隔��d��则：应当为客��h��供尽可能��的接口�Q�而不是提供大的接口�?br>    5、组合、聚合复用原则：要尽量��用组合、聚合，而不是��承关�p�M��辑ֈ�复用的目的�?br>    6、Demeter法则�Q�一个��Y件实体应该与��可能少的其他实体发生互�怽�用�?br>    可以��_��<里很好的解决了我心中两三�q�来的不快，让我真正理解了�ؓ什么要使用设计模式。��Y件开发、设计原�? 与设计模式的关系�Q�我不恰当的比喻为战争、战略与战术的关�p�；要取得战争的全面胜利�Q�你首先要在战略上把握好�Q�然后才是战术上指挥好；同样�Q�要开发出好的软�g�Q�我们首先要遵��@一定的设计原则�Q��ؓ了达到我们的目的�Q�在开发中我们��恰当的使用相应的设计模式�?br>    <写的好，而且是中国�h写的�Q�但它缺��了一个方面的描述�Q�我们怎样在实际的设计开发中做到�q�些呢？是不是一开始就要遵循这些设计原则，��p��使用设计模式�Q�还是有一个什么样的过�E�？
    �l�于今年初看��C��英文�?lt;<敏捷软�g开发：原则、模式与实践>>�Q? 国外�q�些大牛��是大牛�Q�在�q�方面就是理解深刻，实践�l�验丰富。作者的观点很有点唯物��L证法�Q�就是��Y件设计开始时�Q�我们如果没有看出抽象的必要�Q�可以先实现一个简单的�Q�当�W�一�ơ被需求触发而显现出抽象的必要时�Q�我们这时机会就来了�Q�需要很快提取抽象接口，遵��@以上设计原则。当�Ӟ��作者还有很多其它好的思想�Q? �q�里不一一列�D�?br>    认识和理解都需要一个过�E�，没有理论�Q�我们这些智商一般的人是很难仅仅在项目开发中��快提高的；同样�Q�光看书不实践，我们也很隄��正理解这些别人�ȝ��的经验，那将是雾里看花�?br>    丰富�l�验和��Y件设计思想以及软�g工程思想�Q�对软�g开发的重要性真的是如此重要�Q�怪不得我们国家无法开发出大型的高质量的��Y件来�?br>

RichardHe 2008-05-14 10:37 发表评论

久久久久久无码Av成人影院,久久无码一区二区三区少妇,欧美一区二区久久精品

���介Boost.Regex

boost::regex

boost::regex

extern "C"

推荐--丰富的游戏开发的站点

用Boost.Spirit写了一个term下c++词法高亮

内存分区

回调函数

Boost.Singals 教程

[摘录]回调函数与�{�U�表

MD5���法的C++实现

��Z��C++有限状态机的实现技�?调查报告)

接口设计的要点（接口不应被��用者直接销毁）

在C++中侦���内嵌类型的存在

boost源码剖析之：泛型�~�程�_����type_traits

boost源码剖析之：boost::multi_array

boost源码剖析之：Tuple Types

刘未鹏之《boost源码剖析》系列多重回调机制signal

Boost.Bind的基���使用

callback function

OOD原则�Q�SRP、OCP以及LSP

理解: 面向对象的设计原则与设计模式

��介Boost.Regex

MD5��法的C++实现

在C++中侦��内嵌类型的存在

boost源码剖析之：泛型�~�程�_��type_traits

Boost.Bind的基��使用