简介¹
    正 则表达式（Regular expression）是一种在文本处理中经常用到的模式匹配的形式，可能许多用户熟悉Unix下的grep,sed,awk等工具或者perl语言，它 们都广泛地用到了正则表达式。传统的C++用户还受限于用POSIX C API's（Portable operateing system interface standard)来操作正则表达式，而regex++已经提供了这些API's，虽然它不一定是使用POSIX C 正则表达式库的最好方法。比如regex++能处理宽字符字符串（wide character strings），或者搜索、替换操作（在某种意义上类似于sed或perl），这些在传统的C 库中是不能实现的。
类boost::reg_expression是regex++库中的关键类，它表示“机器可读”的正则表达式，reg_expression 是在string的基础之上构建的，可以认为它是一个具有string的功能，外加这个正则表达式算法所需要的状态机。
像std::basic_string一样，它提供了两个针对char和wchar_t的特化版本：

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

    要知道regex++库到底有什么用？可以试想我们要写一个信用卡处理程序。信用卡通常有16位数字组成的 号码，其中每四位一组，用空格或连字号隔开。在将这些信用卡号码存入数据库之前，我们难道不要检验这些数字是否符合正确格式么？为了匹配任何一个数字我们 可以用正则表达式[0-9]，数字串的宽度可以用[[:digit:]],当然这些是POSIX标准。在regex++和perl中可简化为\d（注意许 多老的库倾向于硬编码到C-locale，因此这不是什么问题）。下面的正则表达式可以检验信用卡号码的格式。
(\d{4}[- ]){3}\d{4}
    ()标记子表达式，{4}表示重复4次。这仅是一个perl,awk,egrep的正则表达式的例子。regex++也支持那些sed,grep用到的比较老的“基本”语法，虽然它们很少用到，除非你需要重用一些已有的基本正则表达式。

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

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

    注意我们以前是如何将某些额外的转义序列（或者翻译成：转义字符）添加到表达式的：要知道，正则表达式引擎处理转义字符前，该转义字符只能被 C++编译器识别一次，因此，在C++代码中嵌入正则表达式的转义字符必须双写（写两次）。
    还要注意到你的编译器必须支持Koening lookup 2（比如VC6就不支持），否则你需要附加一些boost::prefixes到某些函数引用中。
    那 些熟悉信用卡操作的人，可能还会想到上面的那种格式适合于人的阅读，并不表示网上信用卡系统要求的格式（可能是16或15个没有间隔符的数字串）。我们需 要一种简单的转换方法，我们需要2个字符串，1个是正则表达式，一个是格式字符串（提供一种被匹配的内容的描述）。在regex++中，search和 replace都能完成regex_merge算法，对于信用卡的例子我们给出了下面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);
}

    这儿，我们用正则表达式中的子式把号码分为4块，format string 用类似sed的语法把被匹配的内容替换为规定格式。
    上面的例子中，我们还没有直接操作匹配结果，匹配结果包括全体匹配和一些子式的匹配。当需要正则表达式的匹配结果时，就需要用到class match_results的实例，下面是常用类型的特化版本：

namespace boost{
typedef match_results<const char*> cmatch;
typedef match_results<const wchar_t*> wcmatch;
typedef match_results<std::string::const_iterator> smatch;
typedef match_results<std::wstring::const_iterator> wsmatch;
}

    regex_search和regex_grep算法都使用到match_result。
    注意这些算法并不局限于一般的C-strings,任何双向迭代器（bidirectional iterator）类型都能被搜索，这为无缝搜索任何类型数据提供了可能性。

    对于那些不喜欢模板（templates）的人还可以使用class RegEx,它是对模板代码的高层次包装，它为那些使用不到库的整个功能的人提供了简单的接口，当然它仅支持窄字符（narrow character）和“扩展”的正则表达式语法。
    对于想兼容POSIX的人可以使用POSIXAPI函数：regcomp,regexec,regfree,regerror,这些对narrow character和Unicode都适用。

    最后注意，这个库现在支持运行时本地化（run-time localization），它能完全识别POSIX正则表达式语法，包括一些多字符的元素比较和同等类型的高级特性，它还能兼容其它一些正则表达式库包括GNU、BSD4的regex包。

安装和配置

    首先当你从zip文件解压本库时必须保留它的内部结构，如果你没这样做，那只好删除你解压的文件，重现来一次。
    由于支持大多数常见的编译器/标准库/平台，这个库不需要作使用前的配置。如果你碰到配置问题，或想测试你的编译器的配置信息，可以参考 配置文档（这和boost的其它所有的库的处理过程都一样）。

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

最后只需添加<boost>根目录到你的工程所包含的目录列表中。没有必要手动将*.lib文件加到工程中，因为在头文件会选择正确的.lib文件。
注意：如果想静态地链入regex库，可定义BOOST_REGEX_STATIC_LINK（在release版中生效）。
      如果想直接使用源文件，可定义BOOST_REGEX_NO_LIB，这样自动选择库将失效。

1.简介出处：http://www.boost.org/libs/regex/doc/introduction.html
2.Koening lookup：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.

以下是假设旧的C程序库

C的头文件

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

C的源文件

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

C++的调用

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

这样编译会产生错误cpp.obj : error LNK2001: unresolved external symbol "int __cdecl add(int,int)" (?add@@YAHHH@Z)，原因是找不到add的目标模块

这才令我想起C++重载的函数命名方式和C函数的命名方式，让我们回顾一下：C中函数编译后命名会在函数名前加以"_",比如add函数编译成obj文件时的实际命名为_add，而c++命名则不同，为了实现函数重载同样的函数名add因参数的不同会被编译成不同的名字

例如

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

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

以上是VC6的命名方式，不同的编译器会不同，总之不同的参数同样的函数名将编译成不同目标名，以便于函数重载是调用具体的函数。

编译cpp.cpp中编译器在cpp文件中发现add(1, 0);的调用而函数声明为extern int add(int x, int y);编译器就决定去找add@@YAHHH@Z，可惜他找不到，因为C的源文件把extern int add(int x, int y);编译成_add了；

为了解决这个问题C++采用了extern "C",这就是我们的主题，想要利用以前的C程序库，那么你就要学会它，我们可以看以下标准头文件你会发现，很多头文件都有以下的结构

#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*/

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

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

extern int add(int, int);

#ifdef __cplusplus
}
#endif

#endif /* _C_H_ */ 

这样编译

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

这时源文件为*.c，__cplusplus没有被定义，extern "C" {}这时没有生效对于C他看到只是extern int add(int, int);
add函数编译成_add(int, int);

而编译c++源文件

/*-----------cpp.cpp--------------*/
#include "c.h"
void main()
{
add(1, 0);
}
这时源文件为*.cpp,__cplusplus被定义,对于C++他看到的是extern "C" {extern int add(int, int);}编译器就会知道 add(1, 0);调用的C风格的函数，就会知道去c.obj中找_add(int, int)而不是add@@YAHHH@Z；

1.1版，命令行下使用如1.0版，

    增加更易用的方法：点击coco.exe，将文件拖入窗口，高亮文件输出到同名txt文件中

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

1.0版：命令行下使用，输出到stdout，

可以重定向到文件，彩色复制就行了
coco.exe xxx.cpp > whateverfile
记事本打开whateverfile，复制，在bbs上彩色粘贴
编译这个大概需要2百多M内存

想直接现在用的，可以在这下载，这是水木的附件，不知道能有效到什么时候

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

论坛可以用它来实现代码高亮显示
以后再改进

正确的代码coco应该不会分析错，能分析正确的不一定是正确的代码

读代码可以先看spirit最基础的ch_p,str_p等，还有spirit文档中的utility

再看如何分析文件

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

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

二来是要做个课程设计，三来这个很实用，平常在水木帖代码也能用的上

五大内存分区
    在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
    栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。
    堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
    自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
    全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
    常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）
明确区分堆与栈
    在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
    首先，我们举一个例子：
    void f() { int* p=new int[5]; }
    这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是： 在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：
    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
    这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。
    好了，我们回到我们的主题：堆和栈究竟有什么区别？
    主要的区别由以下几点：
    1、管理方式不同；
    2、空间大小不同；
    3、能否产生碎片不同；
    4、生长方向不同；
    5、分配方式不同；
    6、分配效率不同；
    管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
    空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。当然，我们可以修改：   
    打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
    碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题， 因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的 可以参考数据结构，这里我们就不再一一讨论了。
    生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
    分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
    分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比 较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆 内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分 到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
    从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态 和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地 址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。
    虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。
    无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就 算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的：）
    对了，还有一件事，如果有人把堆栈合起来说，那它的意思是栈，可不是堆，呵呵，清楚了？
static用来控制变量的存储方式和可见性
       函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？ 最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此 函数控制）。

       需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见。

       static的内部机制：
       静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。
       这样，它的空间分配有三个可能的地方，一是作为类的外部接口的头文件，那里有类声明；二是类定义的内部实现，那里有类的成员函数定义；三是应用程序的main（）函数前的全局数据声明和定义处。
      静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。类声明只声明一个类的“尺寸和规格”，并不进行实际的内存分配，所以在类声 明中写成定义是错误的。它也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。
      static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态
数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。

       static的优势：
       可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的 值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。

        引用静态数据成员时，采用如下格式：
         <类名>::<静态成员名>
    如果静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式
来引用静态数据成员。

       PS:
      (1)类的静态成员函数是属于整个类而非类的对象，所以它没有this指针，这就导致
了它仅能访问类的静态数据和静态成员函数。
      (2)不能将静态成员函数定义为虚函数。
      (3)由于静态成员声明于类中，操作于其外，所以对其取地址操作，就多少有些特殊
，变量地址是指向其数据类型的指针 ，函数地址类型是一个“nonmember函数指针”。

简介

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

　　什么是回调函数？

　　简而言之，回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。

　　为什么要使用回调函数？

　　因为可以把调用者与被调用者分开。调用者不关心谁是被调用者，所有它需知道的，只是存在一个具有某种特定原型、某些限制条件（如返回值为int）的被调用函数。

如果想知道回调函数在实际中有什么作用，先假设有这样一种情况，我们要编写一个库，它提供了某些排序算法的实现，如冒泡排序、快速排序、shell排 序、shake排序等等，但为使库更加通用，不想在函数中嵌入排序逻辑，而让使用者来实现相应的逻辑；或者，想让库可用于多种数据类型（int、 float、string），此时，该怎么办呢？可以使用函数指针，并进行回调。

　　回调可用于通知机制，例如，有时要在程序中设置一个 计时器，每到一定时间，程序会得到相应的通知，但通知机制的实现者对我们的程序一无所知。而此时，就需有一个特定原型的函数指针，用这个指针来进行回调， 来通知我们的程序事件已经发生。实际上，SetTimer() API使用了一个回调函数来通知计时器，而且，万一没有提供回调函数，它还会把一个消息发往程序的消息队列。

　　另一个使用回调机制的 API函数是EnumWindow()，它枚举屏幕上所有的顶层窗口，为每个窗口调用一个程序提供的函数，并传递窗口的处理程序。如果被调用者返回一个 值，就继续进行迭代，否则，退出。EnumWindow()并不关心被调用者在何处，也不关心被调用者用它传递的处理程序做了什么，它只关心返回值，因为 基于返回值，它将继续执行或退出。

　　不管怎么说，回调函数是继续自C语言的，因而，在C++中，应只在与C代码建立接口，或与已有的回调接口打交道时，才使用回调函数。除了上述情况，在C++中应使用虚拟方法或函数符（functor），而不是回调函数。

　　一个简单的回调函数实现

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

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

　　这两个函数接受以下参数：

　　·byte * array：指向元素数组的指针（任意类型）。

　　·int size：数组中元素的个数。

　　·int elem_size：数组中一个元素的大小，以字节为单位。

　　·CompareFunction cmpFunc：带有上述原型的指向回调函数的指针。

这两个函数的会对数组进行某种排序，但每次都需决定两个元素哪个排在前面，而函数中有一个回调函数，其地址是作为一个参数传递进来的。对编写者来说，不 必介意函数在何处实现，或它怎样被实现的，所需在意的只是两个用于比较的元素的地址，并返回以下的某个值（库的编写者和使用者都必须遵守这个约定）：

　　·-1：如果第一个元素较小，那它在已排序好的数组中，应该排在第二个元素前面。

　　·0：如果两个元素相等，那么它们的相对位置并不重要，在已排序好的数组中，谁在前面都无所谓。

　　·1：如果第一个元素较大，那在已排序好的数组中，它应该排第二个元素后面。

　　基于以上约定，函数Bubblesort()的实现如下，Quicksort()就稍微复杂一点：

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)) 　　　{ 　　　　//两个相比较的元素相交换 　　　　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; 　　　} 　　} 　} }

　　注意：因为实现中使用了memcpy()，所以函数在使用的数据类型方面，会有所局限。

　　对使用者来说，必须有一个回调函数，其地址要传递给Bubblesort()函数。下面有二个简单的示例，一个比较两个整数，而另一个比较两个字符串：

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

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

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

　　如果想进行降序排序（大元素在先），就只需修改回调函数的代码，或使用另一个回调函数，这样编程起来灵活性就比较大了。

调用约定

　　上面的代码中，可在函数原型中找到__stdcall，因为它以双下划线打头，所 以它是一个特定于编译器的扩展，说到底也就是微软的实现。任何支持开发基于Win32的程序都必须支持这个扩展或其等价物。以__stdcall标识的函 数使用了标准调用约定，为什么叫标准约定呢，因为所有的Win32 API（除了个别接受可变参数的除外）都使用它。标准调用约定的函数在它们返回到调用者之前，都会从堆栈中移除掉参数，这也是Pascal的标准约定。但 在C/C++中，调用约定是调用者负责清理堆栈，而不是被调用函数；为强制函数使用C/C++调用约定，可使用__cdecl。另外，可变参数函数也使用 C/C++调用约定。

　　Windows操作系统采用了标准调用约定（Pascal约定），因为其可减小代码的体积。这点对早期的Windows来说非常重要，因为那时它运行在只有640KB内存的电脑上。

　　如果你不喜欢__stdcall，还可以使用CALLBACK宏，它定义在windef.h中：

#define CALLBACK __stdcallor #define CALLBACK PASCAL //而PASCAL在此被#defined成__stdcall

　　作为回调函数的C++方法

　　因为平时很可能会使用到C++编写代码，也许会想到把回调函数写成类中的一个方法，但先来看看以下的代码：

class CCallbackTester { 　public: 　int CALLBACK CompareInts(const byte* velem1, const byte* velem2); }; Bubblesort((byte*)array, 5, sizeof(array[0]), &CCallbackTester::CompareInts);

　　如果使用微软的编译器，将会得到下面这个编译错误：

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

　　这是因为非静态成员函数有一个额外的参数：this指针，这将迫使你在成员函数前面加上static。当然，还有几种方法可以解决这个问题，但限于篇幅，就不再论述了。

摘录自 《C和指针》
1.回调函数
这里有一个简单的函数,它用于在一个单链表中查找一个值,它的参数是一个指向链表第一个节点的指针以及那个需要查找的值.
Node* search_list(Node* node,int const value)
{ 
   while(node!=NULL)
  {  
    if(node->value==value)  break;
    node=node->link;
  }
  return node;
}
 这 个函数看上去相当简单,但它只适用于值为整数的链表,如果你需要在一个字符串链表中查找,你不得不另外编写一个函数,这个函数和上面那个函数的绝大部分代 码相同,只是第二个参数的类型以及节点值的比较方法不同.一种更为通用的方法是查找函数与类型无关,这样它就能用于任何类型的值的链表,我们必须对函数的 两个方面进行修改,使它与类型无关.
首先我们必须改变比较的执行方式,这样函数就可以对任何类型的值进行比较.这个目标听上去好象不可能,如果你 编写语句用于比较整型值,它怎么还可能用于其他类型如字符串的比较呢?解决方案就是使用函数指针,调用者编写一个函数,用于比较两个值,然后把一个指向这 个函数的指针作为参数传递给查找函数.然后查找函数调用这个函数来执行值的比较,使用这种方法,任何类型的值都可以进行比较.我们必须修改的第二个方面是 向函数传递一个指向值的指针而不是本身.函数由一个void *形参,用于接收这个参数,然后指向这个值的指针便传递给比较函数,这个修改使字符串和数组对象也可以被使用,字符串和数组无法作为参数传递给函数,但指 向它们的指针可以.
使用这种技巧的函数叫"回调函数"(callback function);因为用户把一个函数指针作为参数传递给其他函数,后者将"回调"用户的函数.任何时候,如果你所编写的函数必须能够在不同的时刻执行 不同类型的工作或执行只能由函数调用者定义的工作,你都可以使用这个技巧.许多窗口系统使用回调函数连接多个动作,如拖拽鼠标和点击按钮来指定用户程序中 的某个特定函数.我们无法在这个上下文环境中为回调函数编写一个准确的原型,因为我们并不知道进行比较的值的类型.事实上,我们需要查找函数能作用于任何 类型的值,解决这个难题的方法是把参数类型声明为"void *",表示"一个指向未知类型的指针".

/***在一个单链表中查找一个指定值的函数,它的参数是一个指向链表第一个节点
   **的指针,一个指向我们需要查找的值的指针和一个函数指针,它所指向的函数
   **用于比较存储于此链表中的类型的值.
*/
#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所指向的任何节点,但node并未声明为const。如果node被声明为const,函数不得不返回一个const结果，这将限制调用程序，它便无法修改查找函数所找到的节点。
 在一个特定的链表中进行查找时，用户需要编写一个适当的比较函数，并把指向该函数的指针和指向需要查找的值的指针传递给查找函数。
例如，下面是一个比较函数，它用于在一个整数链表中进行查找。
int compare_ints(void const* a,void const* b)
{
    if(*(int*)a==*(int*)b)     return 0;
    else     return 1;
}
这个函数将像下面这样使用：
desired_node=search_list(root,&desired_value,compare_ints);

2.转换表（jump table)
 转移表最好用个例子来解释。下面的代码段取自一个程序，它用于实现一个袖珍式计算器。程序的其他部分已经读入两个数（op1和op2）和一个操作符（oper)。下面的代码对操作符进行测试，最后决定调用哪个函数。
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;
  ......
}

      对于一个新奇的具有上百个操作符的计算器，这条switch语句将会非常之长。为什么要调用函数来执行这些操作呢？把具体操作和选择操作的代码分开是一种 良好的设计方案。更为复杂的操作将肯定以独立的函数来实现，因为它们的长度可能很长。但即使是简单的操作也可能具有副作用，例如保存一个常量值用于以后的 操作。
为了使用switch语句，表示操作符的代码必须是整数。如果它们是从零开始连续的整数，我们可以使用转换表来实现相同的任务。转换表就是一个函数指针数组。
创建一个转换表需要两个步骤。首先，声明并初始化一个函数指针数组。唯一需要留心之处就是确保这些函数的原型出现在这个数组的声明之前。

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,...}；

      初始化列表中各个函数名的正确顺序取决于程序中用于表示每个操作符的整型代码。这个例子假定ADD是0，SUB是1，MUL是2，接下去以此类推。
      第二个步骤是用下面这条语句替换前面整条switch语句！
result=oper_func[oper](op1,op2);
oper从数组中选择正确的函数指针，而函数调用操作符将执行这个函数。

1、模式是应该结合在一起共同解决问题的。

评论：以前看《GOF设计模式》的时候主要就是看目的，然后就是代码，对协作啊，优缺点啊，效果啊都不怎么注意，不过就算看了也不知所云。学下来就像背数学公式一样，单个是记住了，拿到具体环境里又懵了。看来还是得多花点时间看看模式的关联啊。

2、我的错误是：我尝试先创建问题领域中的累，然后将这些类缝合起来形成最终的系统。——Alexander把这样的过程称为一个“坏主意”。我从来没有问过我自己：我是否拥有正确的类？仅仅因为这些类看起来如此正确、如此明显。我拥有的是在开始分析时立刻进入脑海中的类，是我们的老师告诉我们应该在系统中寻找的“名词”。但是我的错误就是仅仅尝试把它们简单地放在一起。

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

3、面向对象的范式：使用对象将责任转义到更局部的范围。对象应该对自己负责，并且这种责任应该被清楚的定义出来。

评论：这个对类的定义就要合理的多。作者认为软件开发中有三个视角：概念（用例）－>规格（接口）－>实现（代码）。从最低层次看，类就是变量+函数，但这样就太狭隘了。真正的对象应该与现实生活中的对象相似，有自己的行为、状态，自己对自己负责（多么精确的概述啊）。

4、抽象类就是其他类的占位符。

评论：比较形象的描述。我先描述类的大致行为供调用者了解，具体的行为留到子类实现，抽象类与子类达成一个契约。

5、过早的对细节投入过多的关心是一个分析缺陷。

评论：同2。

6、留意你的直观：当你看到某些不喜欢的东西时，你胃部的感觉。

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

7、关注模式的场景而非解决方案。

评论：作者自始至终一直强调是场景决定解决方案，而不是为了实现某个模式而去进行设计，否则就像小学生套公式一样了。场景分析好了，模式自然也就出来了（这是境界比较高的时候）。

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

   a、发现并封装变化点。

   b、优先使用对象组合，而非类继承。

评论：关于共同点/变化点的分析，在Bridge模式中体现的犹为明显（我在前面的Blog中介绍过），借助分析矩阵也可以帮助理清思路。而b点是面向对象设计中的基本原则，就不用多说了。

9、switch语句常常标志着：（1）对多态行为的需要。（2）存在着放错地方的责任。请考虑用一种更普适的解决方案代替switch语句，比如抽象、将责任分配给另外的对象等等。

评论：老听别人说丑陋的switch语句、ifelse语句，都不是太懂，现在好像有点懂了，因为条件语句不灵活，很难维护吧。碰到它马上就要想到用多态的方式去处理，像State模式、Visitor模式就和这有关。

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

步骤：

（1）、发现我在问题领域中拥有的模式

（2）、对于这些需要分析的模式，做下列工作：

   a、挑出为其他模式提供最多场景的模式。

   b、在我概念性最高的设计中使用这个模式。

   c、识别任何可能已经出现的附加模式。将它们添加到“需要分析的模式”中。

   d、对需要分析而未分析的模式，重复上述工作。

（3）、按照需要将细节添加的设计中。扩展方法和类定义。

评论：具体的说就是找到可以统领全局的模式，再用其他的模式配合它，“面向模式的设计”(POP)。算了吧，我连OOP都没学好，这个以后再说啦。

11、在学习面向对象技术的早期学习设计模式，可以大大帮助你提高对面向对象分析、设计的理解。

评论：这个倒是第一次听说，不过怎么也得先把继承、封装、多态弄清楚吧。再加上一条，在学习设计模式时，一定要先读这本《设计模式精解》，再看《GOF设计模式》，。