UNICODE编程资料(转贴)

 1. 如何取得一个既包含单字节字符又包含双字节字符的字符串的字符个数？
可以调用Microsoft Visual C++的运行期库包含函数_mbslen来操作多字节（既包括单字节也包括双字节）字符串。
调用strlen函数，无法真正了解字符串中究竟有多少字符，它只能告诉你到达结尾的0之前有多少个字节。

2. 如何对DBCS（双字节字符集）字符串进行操作？
函数 描述
PTSTR CharNext （ LPCTSTR ）; 返回字符串中下一个字符的地址
PTSTR CharPrev （ LPCTSTR, LPCTSTR ）； 返回字符串中上一个字符的地址
BOOL IsDBCSLeadByte( BYTE )； 如果该字节是DBCS字符的第一个字节，则返回非0值

3. 为什么要使用Unicode？
（1） 可以很容易地在不同语言之间进行数据交换。
（2） 使你能够分配支持所有语言的单个二进制.exe文件或DLL文件。
（3） 提高应用程序的运行效率。
Windows 2000是使用Unicode从头进行开发的，如果调用任何一个Windows函数并给它传递一个ANSI字符串，那么系统首先要将字符串转换成 Unicode，然后将Unicode字符串传递给操作系统。如果希望函数返回ANSI字符串，系统就会首先将Unicode字符串转换成ANSI字符串，然后将结果返回给你的应用程序。进行这些字符串的转换需要占用系统的时间和内存。通过从头开始用Unicode来开发应用程序，就能够使你的应用程序更加有效地运行。
Windows CE 本身就是使用Unicode的一种操作系统，完全不支持ANSI Windows函数
Windows 98 只支持ANSI，只能为ANSI开发应用程序。
Microsoft公司将COM从16位Windows转换成Win32时，公司决定需要字符串的所有COM接口方法都只能接受Unicode字符串。

4. 如何编写Unicode源代码？
Microsoft 公司为Unicode设计了WindowsAPI，这样，可以尽量减少代码的影响。实际上，可以编写单个源代码文件，以便使用或者不使用Unicode来对它进行编译。只需要定义两个宏（UNICODE和_UNICODE），就可以修改然后重新编译该源文件。
_UNICODE宏用于C运行期头文件，而UNICODE宏则用于Windows头文件。当编译源代码模块时，通常必须同时定义这两个宏。

5. Windows定义的Unicode数据类型有哪些？
数据类型 说明
WCHAR Unicode字符
PWSTR 指向Unicode字符串的指针
PCWSTR 指向一个恒定的Unicode字符串的指针
对应的ANSI数据类型为CHAR，LPSTR和LPCSTR。
ANSI/Unicode通用数据类型为TCHAR，PTSTR,LPCTSTR。

6. 如何对Unicode进行操作？
字符集 特性 实例
ANSI 操作函数以str开头 strcpy
Unicode 操作函数以wcs开头 wcscpy
MBCS 操作函数以_mbs开头 _mbscpy
ANSI/Unicode 操作函数以_tcs开头 _tcscpy（C运行期库）
ANSI/Unicode 操作函数以lstr开头 lstrcpy（Windows函数）
所有新的和未过时的函数在Windows2000中都同时拥有ANSI和Unicode两个版本。ANSI版本函数结尾以A表示；Unicode版本函数结尾以W表示。Windows会如下定义：
#ifdef UNICODE
#define CreateWindowEx CreateWindowExW
#else
#define CreateWindowEx CreateWindowExA
#endif // !UNICODE

7. 如何表示Unicode字符串常量？
字符集 实例
ANSI "string"
Unicode L"string"
ANSI/Unicode T("string")或_TEXT("string")if( szError[0] == _TEXT(‘J') ){ }

8. 为什么应当尽量使用操作系统函数？
这将有助于稍稍提高应用程序的运行性能，因为操作系统字符串函数常常被大型应用程序比如操作系统的外壳进程Explorer.exe所使用。由于这些函数使用得很多，因此，在应用程序运行时，它们可能已经被装入RAM。
如：StrCat，StrChr，StrCmp和StrCpy等。

9. 如何编写符合ANSI和Unicode的应用程序？
（1） 将文本串视为字符数组，而不是chars数组或字节数组。
（2） 将通用数据类型（如TCHAR和PTSTR）用于文本字符和字符串。
（3） 将显式数据类型（如BYTE和PBYTE）用于字节、字节指针和数据缓存。
（4） 将TEXT宏用于原义字符和字符串。
（5） 执行全局性替换（例如用PTSTR替换PSTR）。
（6）修改字符串运算问题。例如函数通常希望在字符中传递一个缓存的大小，而不是字节。这意味着不应该传递sizeof(szBuffer),而应该传递（sizeof(szBuffer)/sizeof(TCHAR)。另外，如果需要为字符串分配一个内存块，并且拥有该字符串中的字符数目，那么请记住要按字节来分配内存。这就是说，应该调用
malloc(nCharacters *sizeof(TCHAR)),而不是调用malloc(nCharacters)。

10. 如何对字符串进行有选择的比较？
通过调用CompareString来实现。
标志 含义
NORM_IGNORECASE 忽略字母的大小写
NORM_IGNOREKANATYPE 不区分平假名与片假名字符
NORM_IGNORENONSPACE 忽略无间隔字符
NORM_IGNORESYMBOLS 忽略符号
NORM_IGNOREWIDTH 不区分单字节字符与作为双字节字符的同一个字符
SORT_STRINGSORT 将标点符号作为普通符号来处理

11. 如何判断一个文本文件是ANSI还是Unicode？
判断如果文本文件的开头两个字节是0xFF和0xFE，那么就是Unicode，否则是ANSI。

12. 如何判断一段字符串是ANSI还是Unicode？
用IsTextUnicode进行判断。IsTextUnicode使用一系列统计方法和定性方法，以便猜测缓存的内容。由于这不是一种确切的科学方法，因此 IsTextUnicode有可能返回不正确的结果。

13. 如何在Unicode与ANSI之间转换字符串？
Windows函数MultiByteToWideChar用于将多字节字符串转换成宽字符串；函数WideCharToMultiByte将宽字符串转换成等价的多字节字符串。

李阳的一三五法（发音、口语、听力同时突破）

1． 大量收集TOFEL听力全真试题。
2． 查字典、注音标。
3． 看中文并口泽成中文。
4． 反复听并体会五大发音秘诀语调和停顿。
5． 三最法（最快速、最清晰、最大声）地读并模彷多次。
6． 一口气读。
7． 流利、自然地复述。

用这个方法时注意：

1.英语发音不准的人，是无法体会五大发音秘诀，这不能单靠反复模彷就能突破的，因为有些人连辨音和修正能力也没有，我就是这样的一个人。最好有一位教师帮你一一修正。请参考世界知识出版社出版社，＜新东方学校出国考试丛书――听力的弦外之音＞。这里面有很详细讲述五大发音秘诀、语调起伏、语气和音变等问题。
2.三最法中最快速和一口气读容易忽略语调和停顿。例如：下雨天留客天天留我不留。把它很读得很快是没有人知道你说什么。最大声很容易损坏嗓子。
3.必须想像语言环境。
4.我用这个方法后，变得有点狂，目空一切，这不利与人交流。

改进方法：

1.最清晰、从慢到快地反复模彷并注意语调、停顿和五大发音秘诀。
2.两个人反复对话并不断改造对话内容。这样练出来的效果会比大喊的效果来得更自然、更流利、更富感情。
3.记住：一山还有一山高。

钟道隆的逆向法（语音、语法、听力、口语同时突破）

这法是针对新闻听力。

1．购买新闻听力教材BBC、VOA 、CNN 或SPECIAL ENGLISH
2．利用复读机，不许翻书，把每篇文章听懂。
3．逐句把原文听写出来。
4．对比原文、分析错误（语音、拼写、词汇、语法等）
5．将错误听出来。
6．边听边译成中文，并与译文对比。
7．将单词、短语、设法反复将其听懂。
8．模彷。
9．不看书，用新学的单词复述新闻内容。

用这个方法时注意：

1.这个方法很费时，但很快见效（三天左右，但要每天练习十小时以上），一定要有耐心。
2.平常要多看英文报纸、多听中英文广播。
3.这个方法能有效地提高你的辨音能力，特别是对连读、略读、动词第三身、过去分词、名词复读。
4.复读机最好是买步步高的BK－782，保真效果很理想。
5.注意新闻用词，写作特点，可参考钟道隆的＜逆向法巧学英语＞一书。

＜学习的革命＞一书中的磁带辅导阅读方案（听力、阅读同时突破）

1． 使用中山大学出版的CRAZY ENGLISH。
2． 边看书，边听边阅读。
3． 查字典，（单词、短语、习语）并注在书本上。
4． 反复边看书，边听边阅读。
5． 边看中译，边听磁带。

这个方法对四级、初、中级水平或语感不好的人有极大的帮助，能在八周内提高一年半的阅读水平。还有＜同伴指导原则＞和＜音乐辅导方案＞，这是两个很有创新性的方法，能在数周提高一到两年的水平，＝缺点是没有这个条件。

以上的方法是在传统教育下学了十几年英文了, 还是没学好，还是不能用英文自由交流的“哑吧们“的灵丹妙药。

以下是我对英语的一些促成方法。

原则：

1. 学外语不用Step by step, 是可以跑的。老师们所说的一步一步地学，是指要达到文学欣赏、创作等境界。我所说可以跑的，是指要达到普通的听说读写的技能。
2． 练听必练说，练读必练写。语言能力是听说阅写，发音，语法，语气等的集合，是不可分割的。
3． 语言必须是与人共享的。

想一想你还是小孩时，你是怎样学母语的，是不是一开始你爸妈就给你讲解语法，强迫你做语法练习？当然不是，而是先听说，后读写。
语感是来自听觉的，但当中涉及一个辨音能力的问题，即所听到的与原来别人发音的差距，你无法完全知道自已的辨音是否对的，因此你必需把它说出来，人家听懂你的话，代表你的辨音正确，同时可以避免中式英文，多听收音广播，多看原版电影、电视，多听TOEFL真题，多和老外聊天。老外说什么，你就跟着说什么，就像鹦鹉一样。注意的是听说是同时进行的，就像小时候你爸妈教你说话一样。
不知小时候上学时，老师是否强迫你们背了很多中文单词？否则为什么今天很多人老是拿着英语单词书硬哽下去。当中很多人忽略了理解能力的重要性，误以为单词是阅读的核心，试想想，一个英语单词可能有数十个中文解释，你可否单靠记忆或运气就挑对解释？阅读能力是需要长时间的培养，並不是整天泡在单词书里就可以达到的，挑选合适的书，例如原版的专业书，报纸，杂志，试着直接从这些书报中获取信息与知识，这是你的理解能力最好的训练，但挑书有一个原则，就是 “由浅入深，循序渐进”。很多人在阅读时找不住文章的核心内容、主旨、哪些是重要的、哪些是可弃不读的。练习写作就可以帮你解决这一问题，写文章时，你必须考虑到文章的布局、文体、中心思想等问题，这不就正是阅读所碰到的问题吗？因此你的理解能力和阅读速度就大大提高，因为你已懂得找重点和分辨出哪些是可弃不读。要想在英语有更多的长进，读写是不可少的。

至于语法，连读等语音问题其实是不用刻意去学的，只要你在练习听说读写时多加注意，适当时候强化一下就成了。

步骤：

1． 找一个语音很好的人，给你一一改正你的糟透的发音，我当时用了三个月的时音改正发音。
2． 用李阳的方法，突破开口难这一关。
3． 改良了的方法，除了上述所说的，还有
（1）读故事，然后讲故事。
（2）看见什么东西，就用英语自言自语说个不停。
（3）找一个partner,用英语跟她胡说八道。
（4）参加英语演讲比赛。等等。
4． 准备考四级而疯狂的做了一个多月题，迅速突破语法和阅读。
5． 用了磁带辅导方案半年，和读了15本简易本小说，不做一题模拟题，轻松考过六级。
6． 看了很多China daily, 21st century.
7． 大三时，开始帮同班同学补四、六级，我把有关学英语的方法的书通读一篇，又向外语专业的学生、老师请教，思维上飞跃的突破。
8．决心参加写作比赛，利用电脑软件，着迷900英语系列――读写通，每星期坚持写一篇，并找外语专业的同学修改，然后再过两三天后，自己再作第二次修改，再找老师或老外修改第三篇。或有时候模彷范文，先写再对照，后背范文。开始时写150字，后来写400－1000字的文章。半年内达到外语专业学生的大三水平。英语到了这阶段，好像停滞不前。反思数天，原因有：
（1） 阅读量不够
（2） 从小到大，只依赖字典中的中文解释，使对在不同的文章中单词的理解有误差。
（3） 以前Chinadaily, 21st century读多，反而看不懂国外的报纸，因为写稿的人大多是英语专业的人，他们看了很多的文学原著，相对国外的报纸、杂志，由于没有多大的机会接触，使他们的文章用词过份大词小用、死拼硬溱、不准。句子千篇一律，刻意造成像英语那样“多枝共干“即一个句了，共有一个主语或宾语，中间加进了定语、状语从句等类似情况。使文章生硬、表达不清。
（4） 大一大二时完全忽略语法，语法忘了七七八八。
（5） 电影英语的对白并不是如我们所发的音一样，虽然用词很简单，但那些语气语调，连读音变，让我大吃一惊。
9． 探索了一段时间，从＜学习的革命＞一书拿来的idea,采用了以下的新方法：
（1） 背单词，买了ARCO公司的preparation for the TOEFL CD-ROM. 里面有350条TOEFL常用的词汇，而且全部是英英解释，各条词汇都配了例句和纯正的美国发音。反复背诵模彷后，再通过光盘里的两个单词游戏来强化我的记忆。这使我以后可以不依赖中文解释。
（2） 强化阅读：先用钟道隆的逆向法三天，跟着从 www.yahoo.com 收集了大量的新闻，包括World, Business, Science, Tech, Politics. 以三天为一单位，三天内只读同一类新闻，如world. 必须使用Microsoft 的Bookshelf99 和金山词霸3。当遇到新单词，用Bookshelf99找出英英解释，并把这解释朗读数遍，再用金山词霸把单词的发音读出和了解一下中文解释。查字典的时间在一秒左右，这可大大增加阅读的速度和兴趣。再www.abcnews.go.com 寻找并观看即时在线新闻。这样就可以把地名、人名等专有名词的听力完全突破。把自已当成新闻报导员，用刚才所学的英语单词、短句、习语，用自已的语言作新闻报导。有空还可以自已写社论，并从internet里找一些社论，与自已的作个对比。这是一个配合电脑，听说读写完全突破的方法。
（3）用改良了李阳的方法，大量收集全真TOEFL听力试题，并疯狂突破。但使用疯狂方法不能因而变狂，自以为是，否则外语专业的高人前辈不会给你指导。（英语听力突破掌上宝，和TOEFL的模拟题不能用作练作材料，因为这类书的录音磁带忽略了该场境对话应有的语气和感情。）
（4） ARCO公司的preparation for the TOEFL CD-ROM里有大量的语法训练和详细的解释，把这些练习完成后，语法又过了关。
（5） 电影英语：把中山大学出版的＜CRAZY ENGLISH＞和其出版的电影英语对白系列，经过边看原文，边听，对照中文解释，模彷，背诵精采对白等步骤。确定那些语气语调，连读音变的句子你是无法听懂的，跑到外语系找老师、老外帮你听一听，并跟他们学到底是如何发音的。平常还要经常看英语电视节目（如Start TV, Start Sport, VCD等），用在电视学来的东西，到学校里的外语角跟老师、老外、其他高人前辈谈天说笑。一旦突破了英语节目的听力，你的英语就如鱼得水。
10． 今年大四，跟着就是去挑战TOEFL和英语专业八级的考试，阅读原版的专业书，以英语来学习。大四下学期，用以上所述的方法，突破日语、德语（我想只是皮毛而已）。

这方法关键是要能形成一个学习团体，与人共学，互相促成，一个人是无法成功的，两三个人一起听新闻，然后互相补充，以英语说出来，写作互相批改。并须配合电脑、SOFTWARE、INTERNET，电视，VCD，复读机，书本教材和老师、老外、高人前辈的指点等，才能在有限的时间内促成英语的听说读写的基本技能，学英语其实只要两三年的时间就可以，一般人要达到精通听说读写只需4000学时，为什么却要我们苦学十多年却不得其道？

http://BugEyes.blog.edu.cn

突然对lisp很感兴趣,发誓要剥去她神秘的外衣(in short time)

google了一下,先把相关网站记录一下,呵呵.

中文blog  http://blog.csdn.net/windoze/

http://daiyuwen.freeshell.org/gb/lisp.html

foreigner: http://www.paulgraham.com/lisp.html

// silent.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

int main(int argc, char* argv[])
{
 STARTUPINFO si;
 PROCESS_INFORMATION pi;
    char temp[100];
 ZeroMemory(temp,100);
 ZeroMemory( &si, sizeof(si) );
    si.cb = sizeof(si);
    ZeroMemory( &pi, sizeof(pi) );
 if (argc<2)
  return 1;

 for ( int i=1;i<argc;i++)
 {
   
    strcat(temp,argv[i]);
    strcat(temp," ");
 }
    printf("argv is %s\n",temp);
 CreateProcess(NULL,temp,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi);
 DWORD x=GetLastError();

 DEBUG_EVENT DebugEv;                   // debugging event information
 DWORD dwContinueStatus = DBG_CONTINUE; // exception continuation
// WaitForSingleObject(pi.hProcess,INFINITE);
 Sleep(5000);
 DebugActiveProcess(pi.dwProcessId);
#if 1
 for(;;)
 {
 
 // Wait for a debugging event to occur. The second parameter indicates
 // that the function does not return until a debugging event occurs.
 
  WaitForDebugEvent(&DebugEv, INFINITE);
  dwContinueStatus = DBG_CONTINUE;
 // Process the debugging event code.
 
  switch (DebugEv.dwDebugEventCode)
  {
   case EXCEPTION_DEBUG_EVENT:
   // Process the exception code. When handling
   // exceptions, remember to set the continuation
   // status parameter (dwContinueStatus). This value
   // is used by the ContinueDebugEvent function.
 
    switch (DebugEv.u.Exception.ExceptionRecord.ExceptionCode)
    {
     case EXCEPTION_ACCESS_VIOLATION:
     // First chance: Pass this on to the system.
     // Last chance: Display an appropriate error.
//      printf("%d 0x%x Access Violation!\n",DebugEv.u.Exception.ExceptionRecord.ExceptionInformation[0],DebugEv.u.Exception.ExceptionRecord.ExceptionInformation[1]);

//这里行为？？？？？？？？
      dwContinueStatus=DBG_EXCEPTION_NOT_HANDLED;
      if(DebugEv.u.Exception.dwFirstChance==0 )
      {
      printf("%d 0x%x Access Violation!\n",DebugEv.u.Exception.ExceptionRecord.ExceptionInformation[0],DebugEv.u.Exception.ExceptionRecord.ExceptionInformation[1]);
       exit(0);
      }

      break;
 
     case EXCEPTION_BREAKPOINT:
     // First chance: Display the current
     // instruction and register values.
      break;
 
     case EXCEPTION_DATATYPE_MISALIGNMENT:
     // First chance: Pass this on to the system.
     // Last chance: Display an appropriate error.
      break;
 
     case EXCEPTION_SINGLE_STEP:
     // First chance: Update the display of the
     // current instruction and register values.
      break;
 
     case DBG_CONTROL_C:
     // First chance: Pass this on to the system.
     // Last chance: Display an appropriate error.
      break;
 
     default:
     // Handle other exceptions.
      break;
    }
 
   case CREATE_THREAD_DEBUG_EVENT:
   // As needed, examine or change the thread's registers
   // with the GetThreadContext and SetThreadContext functions;
   // and suspend and resume thread execution with the
   // SuspendThread and ResumeThread functions.
    break;

   case CREATE_PROCESS_DEBUG_EVENT:
   // As needed, examine or change the registers of the
   // process's initial thread with the GetThreadContext and
   // SetThreadContext functions; read from and write to the
   // process's virtual memory with the ReadProcessMemory and
   // WriteProcessMemory functions; and suspend and resume
   // thread execution with the SuspendThread and ResumeThread
   // functions. Be sure to close the handle to the process image
   // file with CloseHandle.
    break;
 
   case EXIT_THREAD_DEBUG_EVENT:
   // Display the thread's exit code.
    break;
 
   case EXIT_PROCESS_DEBUG_EVENT:
   // Display the process's exit code.
    exit(0);
    break;
 
   case LOAD_DLL_DEBUG_EVENT:
   // Read the debugging information included in the newly
   // loaded DLL. Be sure to close the handle to the loaded DLL
   // with CloseHandle.
    break;
 
   case UNLOAD_DLL_DEBUG_EVENT:
   // Display a message that the DLL has been unloaded.
    break;
 
   case OUTPUT_DEBUG_STRING_EVENT:
   // Display the output debugging string.
    break;
 
  }
 
 // Resume executing the thread that reported the debugging event.
 
 ContinueDebugEvent(DebugEv.dwProcessId, DebugEv.dwThreadId, dwContinueStatus);
 
 }
#endif
 return 0;
}

C++中的虚函数(virtual function)
1.简介
    虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。假设我们有下面的类层次：

class A
{
public:
    virtual void foo() { cout << "A::foo() is called" << endl;}
};

class B: public A
{
public:
    virtual void foo() { cout << "B::foo() is called" << endl;}
};

那么，在使用的时候，我们可以：

A * a = new B();
a->foo();       // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!

    这个例子是虚函数的一个典型应用，通过这个例子，也许你就对虚函数有了一些概念。它虚就虚在所谓“推迟联编”或者“动态联编”上，一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被成为“虚”函数。

    虚函数只能借助于指针或者引用来达到多态的效果，如果是下面这样的代码，则虽然是虚函数，但它不是多态的：

class A
{
public:
    virtual void foo();
};

class B: public A
{
    virtual void foo();
};

void bar()
{
    A a;
    a.foo();   // A::foo()被调用
}

1.1 多态
    在了解了虚函数的意思之后，再考虑什么是多态就很容易了。仍然针对上面的类层次，但是使用的方法变的复杂了一些：

void bar(A * a)
{
    a->foo();  // 被调用的是A::foo() 还是B::foo()？
}

因为foo()是个虚函数，所以在bar这个函数中，只根据这段代码，无从确定这里被调用的是A::foo()还是B::foo()，但是可以肯定的说：如果a指向的是A类的实例，则A::foo()被调用，如果a指向的是B类的实例，则B::foo()被调用。

这种同一代码可以产生不同效果的特点，被称为“多态”。

1.2 多态有什么用？
    多态这么神奇，但是能用来做什么呢？这个命题我难以用一两句话概括，一般的C++教程（或者其它面向对象语言的教程）都用一个画图的例子来展示多态的用途，我就不再重复这个例子了，如果你不知道这个例子，随便找本书应该都有介绍。我试图从一个抽象的角度描述一下，回头再结合那个画图的例子，也许你就更容易理解。

    在面向对象的编程中，首先会针对数据进行抽象（确定基类）和继承（确定派生类），构成类层次。这个类层次的使用者在使用它们的时候，如果仍然在需要基类的时候写针对基类的代码，在需要派生类的时候写针对派生类的代码，就等于类层次完全暴露在使用者面前。如果这个类层次有任何的改变（增加了新类），都需要使用者“知道”（针对新类写代码）。这样就增加了类层次与其使用者之间的耦合，有人把这种情况列为程序中的“bad smell”之一。

    多态可以使程序员脱离这种窘境。再回头看看1.1中的例子，bar()作为A-B这个类层次的使用者，它并不知道这个类层次中有多少个类，每个类都叫什么，但是一样可以很好的工作，当有一个C类从A类派生出来后，bar()也不需要“知道”（修改）。这完全归功于多态--编译器针对虚函数产生了可以在运行时刻确定被调用函数的代码。

1.3 如何“动态联编”
    编译器是如何针对虚函数产生可以再运行时刻确定被调用函数的代码呢？也就是说，虚函数实际上是如何被编译器处理的呢？Lippman在深度探索C++对象模型[1]中的不同章节讲到了几种方式，这里把“标准的”方式简单介绍一下。

    我所说的“标准”方式，也就是所谓的“VTABLE”机制。编译器发现一个类中有被声明为virtual的函数，就会为其搞一个虚函数表，也就是VTABLE。VTABLE实际上是一个函数指针的数组，每个虚函数占用这个数组的一个slot。一个类只有一个VTABLE，不管它有多少个实例。派生类有自己的VTABLE，但是派生类的VTABLE与基类的VTABLE有相同的函数排列顺序，同名的虚函数被放在两个数组的相同位置上。在创建类实例的时候，编译器还会在每个实例的内存布局中增加一个vptr字段，该字段指向本类的VTABLE。通过这些手段，编译器在看到一个虚函数调用的时候，就会将这个调用改写，针对1.1中的例子：

void bar(A * a)
{
    a->foo();
}

会被改写为：

void bar(A * a)
{
    (a->vptr[1])();
}

    因为派生类和基类的foo()函数具有相同的VTABLE索引，而他们的vptr又指向不同的VTABLE，因此通过这样的方法可以在运行时刻决定调用哪个foo()函数。

    虽然实际情况远非这么简单，但是基本原理大致如此。

1.4 overload和override
    虚函数总是在派生类中被改写，这种改写被称为“override”。我经常混淆“overload”和“override”这两个单词。但是随着各类C++的书越来越多，后来的程序员也许不会再犯我犯过的错误了。但是我打算澄清一下：

override是指派生类重写基类的虚函数，就象我们前面B类中重写了A类中的foo()函数。重写的函数必须有一致的参数表和返回值（C++标准允许返回值不同的情况，这个我会在“语法”部分简单介绍，但是很少编译器支持这个feature）。这个单词好象一直没有什么合适的中文词汇来对应，有人译为“覆盖”，还贴切一些。
overload约定成俗的被翻译为“重载”。是指编写一个与已有函数同名但是参数表不同的函数。例如一个函数即可以接受整型数作为参数，也可以接受浮点数作为参数。
2. 虚函数的语法
    虚函数的标志是“virtual”关键字。

2.1 使用virtual关键字
    考虑下面的类层次：

class A
{
public:
    virtual void foo();
};

class B: public A
{
public:
    void foo();    // 没有virtual关键字!
};

class C: public B  // 从B继承，不是从A继承！
{
public:
    void foo();    // 也没有virtual关键字！
};

    这种情况下，B::foo()是虚函数，C::foo()也同样是虚函数。因此，可以说，基类声明的虚函数，在派生类中也是虚函数，即使不再使用virtual关键字。

2.2 纯虚函数
    如下声明表示一个函数为纯虚函数：

class A
{
public:
    virtual void foo()=0;   // =0标志一个虚函数为纯虚函数
};

    一个函数声明为纯虚后，纯虚函数的意思是：我是一个抽象类！不要把我实例化！纯虚函数用来规范派生类的行为，实际上就是所谓的“接口”。它告诉使用者，我的派生类都会有这个函数。

2.3 虚析构函数
    析构函数也可以是虚的，甚至是纯虚的。例如：

class A
{
public:
    virtual ~A()=0;   // 纯虚析构函数
};

    当一个类打算被用作其它类的基类时，它的析构函数必须是虚的。考虑下面的例子：

class A
{
public:
    A() { ptra_ = new char[10];}
    ~A() { delete[] ptra_;}        // 非虚析构函数
private:
    char * ptra_;
};

class B: public A
{
public:
    B() { ptrb_ = new char[20];}
    ~B() { delete[] ptrb_;}
private:
    char * ptrb_;
};

void foo()
{
    A * a = new B;
    delete a;
}

    在这个例子中，程序也许不会象你想象的那样运行，在执行delete a的时候，实际上只有A::~A()被调用了，而B类的析构函数并没有被调用！这是否有点儿可怕？

    如果将上面A::~A()改为virtual，就可以保证B::~B()也在delete a的时候被调用了。因此基类的析构函数都必须是virtual的。

    纯虚的析构函数并没有什么作用，是虚的就够了。通常只有在希望将一个类变成抽象类（不能实例化的类），而这个类又没有合适的函数可以被纯虚化的时候，可以使用纯虚的析构函数来达到目的。

2.4 虚构造函数？
    构造函数不能是虚的。

3. 虚函数使用技巧 3.1 private的虚函数
    考虑下面的例子：

class A
{
public:
    void foo() { bar();}
private:
    virtual void bar() { ...}
};

class B: public A
{
private:
    virtual void bar() { ...}
};

    在这个例子中，虽然bar()在A类中是private的，但是仍然可以出现在派生类中，并仍然可以与public或者protected的虚函数一样产生多态的效果。并不会因为它是private的，就发生A::foo()不能访问B::bar()的情况，也不会发生B::bar()对A::bar()的override不起作用的情况。

    这种写法的语意是：A告诉B，你最好override我的bar()函数，但是你不要管它如何使用，也不要自己调用这个函数。

3.2 构造函数和析构函数中的虚函数调用
    一个类的虚函数在它自己的构造函数和析构函数中被调用的时候，它们就变成普通函数了，不“虚”了。也就是说不能在构造函数和析构函数中让自己“多态”。例如：

class A
{
public:
    A() { foo();}        // 在这里，无论如何都是A::foo()被调用！
    ~A() { foo();}       // 同上
    virtual void foo();
};

class B: public A
{
public:
    virtual void foo();
};

void bar()
{
    A * a = new B;
    delete a;
}

    如果你希望delete a的时候，会导致B::foo()被调用，那么你就错了。同样，在new B的时候，A的构造函数被调用，但是在A的构造函数中，被调用的是A::foo()而不是B::foo()。

3.3 多继承中的虚函数 3.4 什么时候使用虚函数
    在你设计一个基类的时候，如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的。从设计的角度讲，出现在基类中的虚函数是接口，出现在派生类中的虚函数是接口的具体实现。通过这样的方法，就可以将对象的行为抽象化。

    以设计模式[2]中Factory Method模式为例，Creator的factoryMethod()就是虚函数，派生类override这个函数后，产生不同的Product类，被产生的Product类被基类的AnOperation()函数使用。基类的AnOperation()函数针对Product类进行操作，当然Product类一定也有多态（虚函数）。

    另外一个例子就是集合操作，假设你有一个以A类为基类的类层次，又用了一个std::vector<A *>来保存这个类层次中不同类的实例指针，那么你一定希望在对这个集合中的类进行操作的时候，不要把每个指针再cast回到它原来的类型（派生类），而是希望对他们进行同样的操作。那么就应该将这个“一样的操作”声明为virtual。

    现实中，远不只我举的这两个例子，但是大的原则都是我前面说到的“如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的”。这句话也可以反过来说：“如果你发现基类提供了虚函数，那么你最好override它”。

4.参考资料
[1] 深度探索C++对象模型，Stanley B.Lippman，侯捷译

[2] Design Patterns, Elements of Reusable Object-Oriented Software, GOF

对函数调用方式的研究

函数的调用约定主要是声明以下信息：
?    参数的入栈顺序；
?    校正栈顶者；
?    参数传递方式；
?    可否不定参数等。

在 VC++6.0中支持__stdcall、__cdecl、pascal、__fastcall等调用约定，在这里我们研究一下这几种调用约定的具体行为。

编译环境：[VC++6.0]
编译方式：[DEBUG]
代码如下：

// TestCall.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

int __stdcall test_stdcall(char para1, char para2)
{
    para1 = para2;
    return 0;

}

int __cdecl test_cdecl(char para, ...)
{
    char    p = '\n';

    va_list marker;

    va_start( marker, para );
   
 
    while( p != '\0' )
    {
        p = va_arg( marker, char);
        printf("%c\n", p);

    }

    va_end( marker );

    return 0;

}

int pascal test_pascal(char para1, char para2)
{
    return 0;

}

int __fastcall test_fastcall(char para1, char para2, char para3, char para4)
{
    para1 = (char)1;
    para2 = (char)2;
    para3 = (char)3;
    para4 = (char)4;

    return 0;

}
__declspec(naked) void __stdcall test_naked(char para1, char para2)
{
    __asm
    {
        push    ebp
        mov     ebp, esp

        push    eax

        mov     al,byte ptr [ebp + 0Ch]
        xchg    byte ptr [ebp + 8],al
       
        pop     eax
        pop     ebp
        ret     8
    }

//    return ;

}
struct sa{
  double a;
  char b;
  int  c;
 // char d;
  int f;
 
};
struct bita
{
 int a:8;
 int b:8;
 int c:8;
 int d:8;
};
int main(int argc, char* argv[])
{
 sa sa;
 sa.a=1.0;
 sa.b='A';
    sa.c=4;
// sa.d='D';
 sa.f=5;

 printf("sa is %d\n",sizeof(sa));
    bita bita;
 bita.a=1;
 bita.b=2;
 bita.c=3;
 bita.d=4;
 test_stdcall( 'a', 'b' );

    test_cdecl('c','d','e','f','g' ,'h' ,'\0');

    test_pascal( 'e', 'f' );

    test_fastcall( 'g', 'h', 'i', 'j' );

    test_naked( 'k', 'l');

    return 0;
}

;*********************************************************************************************************

首先调用的是test_stdcall( \'a\', \'b\' )，这个函数被声明为 __stdcall 的调用方式，其调用代码如下：

00401138   |.  6A 62                push 62     ;   \'b\'
0040113A   |.  6A 61                push 61     ;   \'a\'
0040113C   |.  E8 D3FEFFFF          call TestCall.00401014

在这里可以清楚地看到，__stdcall的参数传递使用栈方式，入栈顺序是先 \'b\' 后 \'a\' ，所以入栈顺序是从右往左。
其返回值用 eax 传递。

然后看看函数体内的代码：

00401050   /> \\55                   push ebp
00401051   |.  8BEC                 mov ebp,esp
00401053   |.  83EC 40              sub esp,40
00401056   |.  53                   push ebx
00401057   |.  56                   push esi
00401058   |.  57                   push edi
00401059   |.  8D7D C0              lea edi,dword ptr ss:[ebp-40]
0040105C   |.  B9 10000000          mov ecx,10
00401061   |.  B8 CCCCCCCC          mov eax,CCCCCCCC
00401066   |.  F3:AB                rep stos dword ptr es:[edi] ; 以上是保存现场和分配局部变量空间

00401068   |.  8A45 0C              mov al,byte ptr ss:[ebp+C]
0040106B   |.  8845 08              mov byte ptr ss:[ebp+8],al  ; para1 = para2;

0040106E   |.  33C0                 xor eax,eax                 ; return 0;

00401070   |.  5F                   pop edi
00401071   |.  5E                   pop esi
00401072   |.  5B                   pop ebx
00401073   |.  8BE5                 mov esp,ebp
00401075   |.  5D                   pop ebp                     ; 恢复现场
00401076   \\.  C2 0800              retn 8                      ; 校正栈顶

__stdcall在函数体内完成了栈顶的校正。

;*********************************************************************************************************

然后调用了test_cdecl( \'c\',\'d\' )，这个函数被声明为 __cdecl 的调用方式，其调用代码如下：
00401141   |.  6A 64                push 64
00401143   |.  6A 63                push 63
00401145   |.  E8 BBFEFFFF          call TestCall.00401005

一样， __cdecl 的参数传递使用栈方式，入栈顺序是从右往左。
其返回值用 eax 传递。
不过 __cdecl 方式有个特点，他支持可变的参数个数。

来看看函数体内的代码：

0040B6A0   /> \\55                   push ebp
0040B6A1   |.  8BEC                 mov ebp,esp
0040B6A3   |.  83EC 48              sub esp,48
0040B6A6   |.  53                   push ebx
0040B6A7   |.  56                   push esi
0040B6A8   |.  57                   push edi
0040B6A9   |.  8D7D B8              lea edi,dword ptr ss:[ebp-48]
0040B6AC   |.  B9 12000000          mov ecx,12
0040B6B1   |.  B8 CCCCCCCC          mov eax,CCCCCCCC
0040B6B6   |.  F3:AB                rep stos dword ptr es:[edi]     ; 以上是保存现场和分配局部变量空间

                                    ; char    p = \'\\n\';
0040B6B8   |.  C645 FC 0A           mov byte ptr ss:[ebp-4],0A

                                    ; va_start( marker, para );
0040B6BC   |.  8D45 0C              lea eax,dword ptr ss:[ebp+C]
0040B6BF   |.  8945 F8              mov dword ptr ss:[ebp-8],eax

                                    ; while( p != \'\\0\' )
0040B6C2   |>  0FBE4D FC            /movsx ecx,byte ptr ss:[ebp-4]
0040B6C6   |.  85C9                 |test ecx,ecx
0040B6C8   |.  74 26                |je short TestCall.0040B6F0
                                    |
                                    |; p = va_arg( marker, char) // 返回当前参数，并使参数指针指向下一个参数
0040B6CA   |.  8B55 F8              |mov edx,dword ptr ss:[ebp-8]
0040B6CD   |.  83C2 04              |add edx,4
0040B6D0   |.  8955 F8              |mov dword ptr ss:[ebp-8],edx
0040B6D3   |.  8B45 F8              |mov eax,dword ptr ss:[ebp-8]
0040B6D6   |.  8A48 FC              |mov cl,byte ptr ds:[eax-4]
0040B6D9   |.  884D FC              |mov byte ptr ss:[ebp-4],cl
                                    |
                                    |; printf("%c\\n", p);
0040B6DC   |.  0FBE55 FC            |movsx edx,byte ptr ss:[ebp-4]
0040B6E0   |.  52                   |push edx                                      ; /Arg2
0040B6E1   |.  68 0CF14100          |push TestCall.0041F10C                        ; |Arg1 = 0041F10C ASCII "%c
"
0040B6E6   |.  E8 45020000          |call TestCall.0040B930                        ; \\TestCall.0040B930
                                    |
0040B6EB   |.  83C4 08              |add esp,8  ; printf 声明为 __cdecl , 由调用者校正栈顶
0040B6EE   |.^ EB D2                \\jmp short TestCall.0040B6C2

0040B6F0   |>  C745 F8 00000000     mov dword ptr ss:[ebp-8],0      ; va_end( marker );

0040B6F7   |.  33C0                 xor eax,eax ; return 0;

0040B6F9   |.  5F                   pop edi
0040B6FA   |.  5E                   pop esi
0040B6FB   |.  5B                   pop ebx
0040B6FC   |.  83C4 48              add esp,48
0040B6FF   |.  3BEC                 cmp ebp,esp
0040B701   |.  E8 7A5AFFFF          call TestCall.00401180
0040B706   |.  8BE5                 mov esp,ebp
0040B708   |.  5D                   pop ebp     ; 恢复现场
0040B709   \\.  C3                   retn

由于支持可变的参数个数，函数无法校正栈顶，所以这个活就留给了调用者：
0040114A   |.  83C4 08              add esp,8   ; 校正栈顶

可变参数的使用很危险，如果不知道怎样结束的话，va_arg宏会执行到出现内存访问错误为止，
而且对参数的类型控制和识别也很麻烦。

;*********************************************************************************************************

看看test_pascal( \'e\', \'f\' )，这个函数被声明为 pascal 的调用方式，其调用代码如下：
0040114D   |.  6A 66                push 66
0040114F   |.  6A 65                push 65
00401151   |.  E8 B9FEFFFF          call TestCall.0040100F

和 __stdcall 一样， pascal 的参数传递使用栈方式，入栈顺序是从右往左，其返回值用 eax 传递。

按照 MASM32 的约定来看， pascal 的参数入栈顺序是从左往右才对啊，奇怪。

然后看看函数体内的代码：

004010B0   /> \\55                   push ebp
004010B1   |.  8BEC                 mov ebp,esp
004010B3   |.  83EC 40              sub esp,40
004010B6   |.  53                   push ebx
004010B7   |.  56                   push esi
004010B8   |.  57                   push edi
004010B9   |.  8D7D C0              lea edi,dword ptr ss:[ebp-40]
004010BC   |.  B9 10000000          mov ecx,10
004010C1   |.  B8 CCCCCCCC          mov eax,CCCCCCCC
004010C6   |.  F3:AB                rep stos dword ptr es:[edi] ; 以上是保存现场和分配局部变量空间

004010C8   |.  33C0                 xor eax,eax ; return 0;

004010CA   |.  5F                   pop edi
004010CB   |.  5E                   pop esi
004010CC   |.  5B                   pop ebx
004010CD   |.  8BE5                 mov esp,ebp
004010CF   |.  5D                   pop ebp     ; 恢复现场
004010D0   \\.  C2 0800              retn 8      ; 校正栈顶

如果定义了<windows.h>， pascal 和 __stdcall 没有什么区别，
如果没有定义<windows.h>程序一编译就会报错。

可能是为了兼容才让 pascal 约定存在的。

;*********************************************************************************************************

接着是test_fastcall( \'g\', \'h\', \'i\', \'j\' )，这个函数被声明为 __fastcall 的调用方式，其调用代码如下：
00401156   |.  6A 6A                push 6A
00401158   |.  6A 69                push 69
0040115A   |.  B2 68                mov dl,68
0040115C   |?  B1 67                mov cl,67
0040115E   |?  E8 C0FEFFFF          call TestCall.00401023

这个有意思，是通过寄存器方式传递参数的，不过只能有两个寄存器参与， ecx 和 edx ，其余的还是用栈了，要珍惜啊，呵呵。
嗯，用寄存器的确是比访问内存要快得多。
其返回值用 eax 传递。

看看函数体内的代码：

004010E0   /> \\55                   push ebp
004010E1   |.  8BEC                 mov ebp,esp
004010E3   |.  83EC 48              sub esp,48
004010E6   |.  53                   push ebx
004010E7   |.  56                   push esi
004010E8   |.  57                   push edi
004010E9   |.  51                   push ecx
004010EA   |.  8D7D B8              lea edi,dword ptr ss:[ebp-48]
004010ED   |.  B9 12000000          mov ecx,12
004010F2   |.  B8 CCCCCCCC          mov eax,CCCCCCCC
004010F7   |.  F3:AB                rep stos dword ptr es:[edi] ; 以上是保存现场和分配局部变量空间

004010F9   |.  59                   pop ecx                     ; 获得第一个参数\'g\'
004010FA   |.  8855 F8              mov byte ptr ss:[ebp-8],dl  ; 获得第二个参数\'h\'
004010FD   |.  884D FC              mov byte ptr ss:[ebp-4],cl  ; 获得第一个参数\'g\'
00401100   |.  C645 FC 01           mov byte ptr ss:[ebp-4],1   ; para1 = (char)1;
00401104   |.  C645 F8 02           mov byte ptr ss:[ebp-8],2   ; para2 = (char)2;
00401108   |.  C645 08 03           mov byte ptr ss:[ebp+8],3   ; para3 = (char)3;
0040110C   |.  C645 0C 04           mov byte ptr ss:[ebp+C],4   ; para4 = (char)4;

00401110   |.  33C0                 xor eax,eax                 ; return 0;

00401112   |.  5F                   pop edi
00401113   |.  5E                   pop esi
00401114   |.  5B                   pop ebx
00401115   |.  8BE5                 mov esp,ebp
00401117   |.  5D                   pop ebp                     ; 恢复现场
00401118   \\.  C2 0800              retn 8                      ; 校正栈顶

开始就把寄存器参数保存在 [ebp - 4] 和 [ebp - 8] 的局部变量里，其余的参数还是在栈底。
在函数体内完成了栈顶的校正。

;*********************************************************************************************************

最后试一下 __declspec(naked) 的感觉，这个不是函数的调用约定，而是指定编译器的处理方式。
其调用代码如下：
00401163   |.  6A 6C                push 6C
00401165   |.  6A 6B                push 6B
00401167   |.  E8 B2FEFFFF          call TestCall.0040101E

这里使用的是 __stdcall 方式，在前面已经研究过了。

函数体内的代码：

0040B5D0   /> \\55                   push ebp
0040B5D1   |.  8BEC                 mov ebp,esp
0040B5D3   |.  50                   push eax
0040B5D4   |.  8A45 0C              mov al,byte ptr ss:[ebp+C]
0040B5D7   |.  8645 08              xchg byte ptr ss:[ebp+8],al
0040B5DA   |.  58                   pop eax
0040B5DB   |.  5D                   pop ebp
0040B5DC   \\.  C2 0800              retn 8

和我写的比较一下看看：

__declspec(naked) void __stdcall test_naked(char para1, char para2)
{
    __asm
    {
        push    ebp
        mov     ebp, esp

        push    eax

        mov     al,byte ptr [ebp + 0Ch]
        xchg    byte ptr [ebp + 8],al
        
        pop     eax
        pop     ebp
        ret     8
    }

}

完全是一样的，只不过没有我写的好看:)。

这种处理方式高度自由，编译器不帮你生成保存现场和分配局部变量空间的代码，一切得靠自己的双手来解决，包括返回值的处理。
可能在底层的控制方面会有作用，编译器不会碍事嘛。

;*********************************************************************************************************

 Calling Convertion,不同的函数调用方式往往会导致混合编程中相互调用的出错。C＋＋默认使用的是的__cdecl方式，这样生成的DLL如果在 DELPHI中使用stdcall方式调用是会出错的，下文对各种主要的函数调用方式做了一个比较详细的解释。

函数调用的不同方式

Visual C/C++编译器使用若干种方式来调用内部和外部的函数。理解这些不同的方式有助于我们来调试程序和链接我们的代码。以下文字解释了不同的函数调用方式下，参数的传递，函数返回值的返回等。同时，也讨论了无参函数的调用。

Visual C/C++ 支持若干种不同的函数调用转换。所有的参数再传递时被设置为32位大小。除了8byte的结构体返回在EDX:EAX寄存器对上，其他的返回值也被设置为 32位，并且返回在EAX寄存器中。大的结构体则以一个指向隐藏的返回结构体指针保存在EAX寄存器中。参数是从右向左压入堆栈中。如果寄存器ESI, EDI,EBX,EBP寄存器在函数中使用，编译器产生prolog和epilog代码来保存和恢复它们。

Visual C/C++ 编译器支持以下的调用转换：
关键字               堆栈清除者    参数传递
__cdecl              调用者       从右向左的顺序压入堆栈内
__stdcall            被调用者     从右向左的顺序压入堆栈内
__fastcall           被调用者     保存在寄存器中，然后其他的压入堆栈内
thiscall(非关键字)    被调用者     压入堆栈，this指针保存在ECX寄存器内

调用方式解析：
void    calltype MyFunc( char c, short s, int i, double f );
calltype代表不同的调用方式

__cdecl调用：
在VC中的编译器选项是/Gd。这是C和C++程序的缺省函数调用转换方式。由于堆栈是由调用者清除的，所以它能调用vararg函数。以__cdecl 调用方式编译的程序比__stdcall大，因为以__stdcall方式编译的程序需要在每个函数调用中包含堆栈清空的代码。
以C方式修饰的函数名是_MyFunc。
__cdecl调用方式的示例图：


__stdcall调用:
在VC中的编译器选项是/Gz。
以C方式修饰的函数名是_MyFunc@20。20是参数的字节数（5×4bytes）。C++方式修饰的名称是私有的，各个编译器可能不同。
 __stdcall and thiscall 调用方式的示例图:

 __fastcall调用:
 在VC中的编译器选项是/Gr。
以C方式修饰的函数名是@MyFunc@20。C++方式修饰的名称是私有的，各个编译器可能不同。
__fastcall调用方式的示例图:

thiscall调用：
这是无参C++成员函数的默认调用方式。调用者负责清空堆栈，this指针第一个入栈。因为没有对应的关键字，所以thiscall方式的调用不可在程序中被显式定义。所有的函数参数都压入堆栈。这种调用方式只应用于C++，所以没有C方式的命名修饰。

2，对于全局对象或全局变量来说，在程序运行即WINMAIN函数加载的时候，已经为全局对象或全局变量分配了内存和赋初值。
所以：CTEApp theApp;->CTEApp ::CTEApp(){}->_tWinMain(){}
说明：每一个MFC程序，有且只有一个从WinApp类派生的类（应用程序类），也只有一个从应用程序类所事例化的对象，表示应用程序本身。在WIN32程序当中，表示应用程序是通过WINMAIN入口函数来表示的（通过一个应用程序的一个事例号这一个标识来表示的）。在基于MFC应用程序中，是通过产生一个应用程序对象，用它来唯一的表示了应用程序。

3，通过构造应用程序对象过程中调用基类CWinApp的构造函数，在CWinApp的构造函数中对程序包括运行时一些初始化工作完成了。
CWinApp构造函数：MFC|SRC|APPCORE.CPP
CWinApp::CWinApp(LPCTSTR lpszAppName){...}//带参数，而CTEApp构造函数没有显式向父类传参，难道CWinApp()有默认参数？见下：
（在CWinApp类定义中， CWinApp(LPCTSTR lpszAppName = NULL); ）
注意：CWinApp()函数中：
pThreadState->m_pCurrentWinThread = this;
pModuleState->m_pCurrentWinApp = this
（this指向的是派生类CTEApp对象，即theApp）
调试：CWinApp::CWinApp();->CTEApp theApp;（->CTEApp ::CTEApp()）->CWinApp::CWinApp()->CTEApp ::CTEApp()->_tWinMain(){}

4,_tWinMain函数中通过调用AfxWinMain()函数来完成它要完成的功能。（Afx*前缀代表这是应用程序框架函数，是一些全局函数，应用程序框架是一套辅助生成应用程序的框架模型，把一些类做一些有机的集成，我们可根据这些类函数来设计自己的应用程序）。
AfxWinMain()函数路径：MFC|SRC|WINMAIN.CPP：
在AfxWinMain()函数中：
CWinApp* pApp = AfxGetApp();
说明：pApp存储的是指向WinApp派生类对象（theApp）的指针。
//_AFXWIN_INLINE CWinApp* AFXAPI AfxGetApp()
// { return afxCurrentWinApp; }

调用pThread->InitInstance()
说明：pThread也指向theApp,由于基类中virtual BOOL InitApplication()定义为虚函数，所以调用pThread->InitInstance()时候，调用的是派生类CTEApp的InitInstance()函数。

nReturnCode = pThread->Run();
说明：pThread->Run()完成了消息循环。

5,注册窗口类：AfxEndDeferRegisterClass();
AfxEndDeferRegisterClass()函数所在文件：MFC|SRC|APPCORE.CPP
BOOL AFXAPI AfxEndDeferRegisterClass(LONG fToRegister){...}
说明：设计窗口类：在MFC中事先设计好了几种缺省的窗口类，根据不同的应用程序的选择，调用AfxEndDeferRegisterClass()函数注册所选择的窗口类。
调试：CWinApp::CWinApp();->CTEApp theApp;（->CTEApp ::CTEApp()）->CWinApp::CWinApp()->CTEApp ::CTEApp()->_tWinMain(){}//进入程序
->AfxWinMain();->pApp->InitApplication()；->pThread->InitInstance()//父类InitInstance虚函数;->CTEApp::InitInstance()//子类实现函数;->AfxEndDeferRegisterClass(LONG fToRegister)//注册所选择的窗口类（出于文档管理，注册提前，正常的应在PreCreateWindow中进行注册）//之后进入创建窗口阶段（以下再不做调试）

6，PreCreateWindow()：//主要是注册窗口类
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
 if( !CFrameWnd::PreCreateWindow(cs) )
  return FALSE;
 return TRUE;
}
说明：
CFrameWnd::PreCreateWindow()函数所在文件：MFC|SRC|WINFRM.CPP
BOOL CFrameWnd::PreCreateWindow(CREATESTRUCT& cs)
{
 if (cs.lpszClass == NULL)
 {
  VERIFY(AfxDeferRegisterClass(AFX_WNDFRAMEORVIEW_REG));
   //判断AFX_WNDFRAMEORVIEW_REG型号窗口类是否注册，如果没有注册则注册
  cs.lpszClass = _afxWndFrameOrView;  // COLOR_WINDOW background
   //把注册后的窗口类名赋给cs.lpszClass
 }

 if ((cs.style & FWS_ADDTOTITLE) && afxData.bWin4)
  cs.style |= FWS_PREFIXTITLE;

 if (afxData.bWin4)
  cs.dwExStyle |= WS_EX_CLIENTEDGE;

 return TRUE;
}

其中：
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);//PreCreateWindow()是个虚函数,如果子类有则调用子类的。
#define VERIFY(f)          ASSERT(f)
#define AfxDeferRegisterClass(fClass) AfxEndDeferRegisterClass(fClass)
define AFX_WNDFRAMEORVIEW_REG          0x00008
const TCHAR _afxWndFrameOrView[] = AFX_WNDFRAMEORVIEW;//WINCORE.CPP文件中，定义为全局数组。
//#define AFX_WNDFRAMEORVIEW  AFX_WNDCLASS("FrameOrView")

7，创建窗口：
Create()函数路径：MFC|SRC|WINFRM.CPP:
CFrameWnd::Create(...){
 ...
 CreateEx(...);//从父类继承来的，调用CWnd::CreateEx().
 ...
}

CWnd::CreateEx()函数路径：MFC|SRC|WINCORE.CPP
BOOL CWnd::CreateEx(...){
 ...
 if (!PreCreateWindow(cs))//虚函数，如果子类有调用子类的。
 {
  PostNcDestroy();
  return FALSE;
 }
 ...
 HWND hWnd = ::CreateWindowEx(cs.dwExStyle, cs.lpszClass,
  cs.lpszName, cs.style, cs.x, cs.y, cs.cx, cs.cy,
  cs.hwndParent, cs.hMenu, cs.hInstance, cs.lpCreateParams);

 ...
}
说明：CreateWindowEx()函数与CREATESTRUCT结构体参数的对应关系，使我们在创建窗口之前通过可PreCreateWindow(cs)修改cs结构体成员来修改所要的窗口外观。PreCreateWindow(cs))//是虚函数，如果子类有调用子类的。
HWND CreateWindowEx(
  DWORD dwExStyle,     
  LPCTSTR lpClassName, 
  LPCTSTR lpWindowName,
  DWORD dwStyle,       
  int x,               
  int y,               
  int nWidth,          
  int nHeight,         
  HWND hWndParent,     
  HMENU hMenu,         
  HINSTANCE hInstance, 
  LPVOID lpParam       
);
typedef struct tagCREATESTRUCT { // cs
    LPVOID    lpCreateParams;
    HINSTANCE hInstance;
    HMENU     hMenu;
    HWND      hwndParent;
    int       cy;
    int       cx;
    int       y;
    int       x;
    LONG      style;
    LPCTSTR   lpszName;
    LPCTSTR   lpszClass;
    DWORD     dwExStyle;
} CREATESTRUCT;

8，显示和更新窗口：
CTEApp类，TEApp.cpp中
m_pMainWnd->ShowWindow(SW_SHOW);//显示窗口，m_pMainWnd指向框架窗口
m_pMainWnd->UpdateWindow();//更新窗口
说明：
class CTEApp : public CWinApp{...}
class CWinApp : public CWinThread{...}
class CWinThread : public CCmdTarget
{
 ...
public:
 CWnd* m_pMainWnd;
 ...
...
}

9，消息循环：
int AFXAPI AfxWinMain()
{ ...
 // Perform specific initializations
 if (!pThread->InitInstance()){...}
 //完成窗口初始化工作，完成窗口的注册，完成窗口的创建，显示和更新。
 nReturnCode = pThread->Run();
 //继承基类Run()方法，调用CWinThread::Run()来完成消息循环
 ...
}
////////////////////////////////////////////////////////////////
CWinThread::Run()方法路径：MFC|SRC|THRDCORE.CPP
int CWinThread::Run()
{ ...
  // phase2: pump messages while available
  do//消息循环
  {
   // pump message, but quit on WM_QUIT
   if (!PumpMessage())//取消息并处理
    return ExitInstance();
   ...
  } while (::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE));
 ...
}
说明：
BOOL PeekMessage(,,,,)函数说明
The PeekMessage function checks a thread message queue for a message and places the message (if any) in the specified structure.
If a message is available, the return value is nonzero.
If no messages are available, the return value is zero.

/////////////////////////////////////////////////////////////
BOOL CWinThread::PumpMessage()
{
 ...
 if (!::GetMessage(&m_msgCur, NULL, NULL, NULL))//取消息
 {...}
 ...
 // process this message
 if (m_msgCur.message != WM_KICKIDLE && !PreTranslateMessage(&m_msgCur))
 {
  ::TranslateMessage(&m_msgCur);//进行消息（如键盘消息）转换
  ::DispatchMessage(&m_msgCur);//分派消息到窗口的回调函数处理（实际上分派的消息经过消息映射，交由消息响应函数进行处理。）
 }
 return TRUE;
}

9，文档与视结构：
可以认为View类窗口是CMainFram类窗口的子窗口。
DOCument类是文档类。
DOC-VIEW结构将数据本身与它的显示分离开。
文档类：数据的存储，加载
视类：数据的显示，修改

10，文档类，视类，框架类的有机结合：
在CTEApp类CTEApp::InitInstance()函数中通过文档模板将文档类，视类，框架类的有机组织一起。
...
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
 IDR_MAINFRAME,
 RUNTIME_CLASS(CTEDoc),
 RUNTIME_CLASS(CMainFrame),       // main SDI frame window
 RUNTIME_CLASS(CTEView));
AddDocTemplate(pDocTemplate);//增加到模板

主要用到的警告表示有如下几个:

once:只显示一次(警告/错误等)消息
default:重置编译器的警告行为到默认状态
1,2,3,4:四个警告级别
disable:禁止指定的警告信息
error:将指定的警告信息作为错误报告

如果大家对上面的解释不是很理解,可以参考一下下面的例子及说明
 
#pragma warning( disable : 4507 34; once : 4385; error : 164 ) 
等价于： 
#pragma warning(disable:4507 34)  // 不显示4507和34号警告信息 
#pragma warning(once:4385)        // 4385号警告信息仅报告一次 
#pragma warning(error:164)        // 把164号警告信息作为一个错误。 
同时这个pragma warning 也支持如下格式： 
#pragma warning( push [ ,n ] ) 
#pragma warning( pop ) 
这里n代表一个警告等级(1---4)。 
#pragma warning( push )保存所有警告信息的现有的警告状态。 
#pragma warning( push, n)保存所有警告信息的现有的警告状态，并且把全局警告 
等级设定为n。  
#pragma warning( pop )向栈中弹出最后一个警告信息，在入栈和出栈之间所作的 
一切改动取消。例如： 
#pragma warning( push ) 
#pragma warning( disable : 4705 ) 
#pragma warning( disable : 4706 ) 
#pragma warning( disable : 4707 ) 
#pragma warning( pop )

在这段代码的最后，重新保存所有的警告信息(包括4705，4706和4707)

在使用标准C++进行编程的时候经常会得到很多的警告信息,而这些警告信息都是不必要的提示,
所以我们可以使用#pragma warning(disable:4786)来禁止该类型的警告

在vc中使用ADO的时候也会得到不必要的警告信息,这个时候我们可以通过
#pragma warning(disable:4146)来消除该类型的警告信息

A-2. 链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、     删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）

B 从内存存储来看
B-1. (静态)数组从栈中分配空间, 对于程序员方便快速,但是自由度小
B-2. 链表从堆中分配空间, 自由度大但是申请管理比较麻烦.

堆和栈的区别 

solost 于 2004年 10月09日 发表 

一、预备知识—程序的内存分配
一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）—   由编译器(Compiler)自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap） —   一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
4、文字常量区  — 常量字符串就是放在这里的。 程序结束后由系统释放
5、程序代码区— 存放函数体的二进制代码。

二、例子程序
这是一个前辈写的，非常详细
//main.cpp
int a = 0; 全局初始化区
char *p1; 全局未初始化区
main()
{
int b; 栈
char s[] = "abc"; 栈
char *p2; 栈
char *p3 = "123456"; 123456\0在常量区，p3在栈上。
static int c =0； 全局（静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); 123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}


二、堆和栈的理论知识
2.1申请方式
stack:
由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间
heap:
需要程序员自己申请，并指明大小，在c中malloc函数
如p1 = (char *)malloc(10);
在C++中用new运算符
如p2 = (char *)malloc(10);
但是注意p1、p2本身是在栈中的。


2.2 申请后系统的响应 
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，
会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

2.3申请大小的限制 
栈：在Windows下, 栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。


2.4申请效率的比较： 
栈由系统自动分配，速度较快。但程序员是无法控制的。
堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

2.5堆和栈中的存储内容 
栈： 在函数调用时，(1) 第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，(2) 然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，(3) 然后是函数中的局部变量。 注意: 静态变量是不入栈的。 
当本次函数调用结束后，(1) 局部变量先出栈，(2) 然后是参数，(3) 最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。 

2.6存取效率的比较 
char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的；
而bbbbbbbbbbb是在编译时就确定的；
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：
#include
void main()
{
char a = 1;
char c[] = "1234567890";
char *p ="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇编代码
10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al
第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。


2.7小结： 
堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。 
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。 

深度优先搜索与广度优先搜索算法有何区别呢？
　　通常深度优先搜索法不全部保留结点，扩展完的结点从数据库中弹出删去，这样，一般在数据库中存储的结点数就是深度值，因此它占用空间较少。所以，当搜索树的结点较多，用其它方法易产生内存溢出时，深度优先搜索不失为一种有效的求解方法。
　　广度优先搜索算法，一般需存储产生的所有结点，占用的存储空间要比深度优先搜索大得多，因此，程序设计中，必须考虑溢出和节省内存空间的问题。但广度优先搜索法一般无回溯操作，即入栈和出栈的操作，所以运行速度比深度优先搜索要快些

sizeof

先整一段网上流传很广的代码，我又加了一点在上面

#include<iostream.h>
class A
{
public:
A();
~A();
virtual void foo() { cout << "A::Vfoo() is called" << endl;}
void function() {...}
};
class B: public A
{
public:
B();
~B();
virtual void foo() { cout << "B::Vfoo() is called" << endl;}
void function() { ...};
void main()
{
A * a = new B;
a->foo(); //B的被调用
a->function();//A的被调用
}

这个地球人都知道了，分析如下:

首先，virtual 是有传递性的。在你的代码中的体现就是：在B的定义中去除foo这个函数前面的那个virtual的话，该函数还是被认为是虚拟函数的；
其次，每个类如果具有虚拟函数（这些虚拟函数有的是自己定义的，有的是通过继承得到的），那么，编译器在存储该类的定义时，会用一个指针（名叫vptr）指向一个数组X。该数组X中的元素的类型是函数指针类型。每一个元素指向一个虚拟函数。这个数组X的学名叫虚拟函数表。这张虚拟函数表的构建方法是：这张虚拟函数表包含基类的虚拟函数，也包含派生类的虚拟函数表。但是，如果派生类中有重写了基类的虚拟函数的话，那么虚拟函数表中对应的元素指向的是派生类的，而不是指向基类的。对于你的代码而言，本来X中存放的函数指针指向了A中的foo，但是因为B重写了这个虚拟函数，于是，编译器将这个指针重新定向，让它指向B中的foo；
然后，如果在程序中出现一个类对象（假设为a），a调用了它的一个成员函数，而该函数是虚拟函数。那么，编译器就会先判断a的实际类型，从而获得正确的vptr，然后在它的虚拟函数表中寻找到相对应的函数指针，最后通过这个函数指针调用正确的虚拟函数。对于你的代码，a的实际类型是B，所以a的虚拟函数表中的函数指针指向的函数是B中的foo；
还有，每个类只有一张虚拟函数表，所有的对象共用这张表。

编译器对于
a->foo();的调用形式如下

int * vptr = ( int * ) * ( int * )a;
int foo_offset = 0;
int * foo_addr = ( int * ) * ( vptr + foo_offset );

typedef void ( * PFunc )();
PFunc pFunc = ( PFunc ) foo_addr;

pFunc();

也可以这样折腾:

void (*func)(A*);
 A* p=new B;//p指向类B的对象，因为B没有数据成员，那么只有虚函数表的地址
 int i;
 memcpy(&i,p,4);//将p指向的内存拷贝4字节到i指向的内存中，就是拷贝vptr
 memcpy(&func,reinterpret_cast<int*>(i),4);//将i转换为指针就是vptr
          //将vptr指向的内存就是虚函数表vptl,拷贝4字节到函数指针func的内存空间
          //注意是&func,就是指针的地址，指向指针本身拥有的4字节空间
 func(p);//现在func就是B中func的地址，func()编译器调用时为func(this)
          //现在this指针只能自己加所以开始要定义为void (*func)(A*)        
 delete p;

再多弄一下,代码如下:
#include "stdafx.h"
#include "stdio.h"
#include "iostream.h"
class A // 大小为12 字节
{
private:
 int i;  //可以被自类继承,但不能被访问
protected:
 int j; //可以被子类继承和访问
public:
 A(){cout << "in the A constructor function"<<endl;i=111;j=222;}
 ~A(){cout << "in the A distructor function"<<endl;}
 virtual void foo() { cout << "A::Vfoo() is called" << endl;}
 void function() {cout << "A:function() is called"<<endl;}
 virtual void hoo(){cout << "A::Vhoo() is called"<<endl;}
};
class C
{
virtual void foo() { cout << "C::Vfoo() is called" << endl;}
virtual void coo() {}
};
class B: public A,public C //大小为16个字节,两个vptr(A,C),i,j
{

//不能访问i
public:
 B(){cout<<"in the B constructor function"<<endl;/*j=20;*/}
 
 void foo() { cout << "B::Vfoo() is called" << endl;}
 void function() { cout << "B:function() is called"<<endl;}
 virtual second(){cout << "B:second() is called"<<endl;}
 ~B(){cout <<"in the B distructor function"<<endl;}
};
void main()
{
 A * pa = new B();
 A a;
    B b;
 printf("a is %d\n",sizeof(a));
 printf("b is %d\n",sizeof(b));
 printf("pa size is %d\n",sizeof(pa));
 pa->foo();
 pa->function ();

 ///////////////////////////////
int * vptr = ( int * ) (* ( int * )pa);
int foo_offset = 0;
int * foo_addr = ( int * ) * ( vptr + foo_offset );

typedef void ( * PFunc )();
PFunc pFunc = ( PFunc ) foo_addr;

pFunc();

 //pa->second();
 return ;
}

要求: 算法中使用的内存数量是一个常数, 即不能因为链表长度的增减使用的内存也增减. 

解析：其实就好象两个人在环形的跑道上跑步，速度快的必定可以超过速度慢的一圈最后相遇。（这个模型可以扩展为一个数组中只有两个相同的数，如何快速找出)

win_hate 回复于：2004-09-20 18:50:29

这个问题应该有很长历史了，《C 专家编程》的附录，程序员工作面试的秘密就提到过这个问题。在这 里我试图对这个问题做一个数学的分析。 如果单链表里存在重复的点，则该链表中包含一个环，事实上，可以用下面的图来表示 这使我想起 Pollard 的 "rho" 算法，事实上本问题与 "rho" 算法有一个共同点，寻找一个碰撞。 从这个图我们可以看到，如果一个单链表里出现了重复的点，则从表头开始走，无论以什么步调，必定 会落到环中。所以我们可以肯定，如果以某个步调走，碰到了NULL，则该链表无重合点。 尝试用两个指针，以不同的步调前进，如果他们能相遇，必定是在环中。假定指针 p 以步调 f 前进，q 以步调 g 前进，g>f。则 q 先进入链表的环。有一种情况很特殊，就是：在 p 刚进入环的时候就与 q  相遇。这是一个小概率事件，我们排除它，不考虑这种情况。可以认为： p 进入环的时候，偏移为 a, 而同时 q 的偏移为 b， 环的长度为 n。（参考下面的图） 往后， p, q 就在圈内打转，它们在x 步后重合的条件为： fx + a = gx + b (mod n) (f-g)x = b-a (mod n) 上式有解等价于  (f-g, n) | (b-a)。  但是，我们在事前不知道 n, 不知道 b-a， 所以唯一能确保 (f-g, n) | (b-a) 成立的是 f-g =1。 只要 f-g = 1, 我们就能一定能检测出重合的情况，这是一个充分条件。 而一旦 p 刚进入环时与 q 不等，(f-g, n) | (b-a) 就成为检测重合的必要条件。前面一些朋友说 f,g  互素或 f, g 不同即可的观点是错误的。从 (f-g, n) | (b-a) 这个条件应该能找到反例。但这个我就 留给有兴趣的朋友了。 f = 1, g = 2 未必是最好的，因为如果 "rho" 的尾巴很长，p 要花费很多工夫才能进入环。此外，虽 然步调大的时候，可能要跑好几个圈才能覆盖整个环，甚至在很多情况下不能覆盖整个环，但它跑一圈 的时间也相应减少，足以抵消。可惜的是，分析最优的选择，超出了我的能力范围。  yangtou 回复于：2004-09-20 19:28:07 不需要考虑细节情况，就可以判断可能性 x=pn/(a-b) > m/b 只要改变p的值就可以找到合适的x，x>m/b所以只要ab不等就必定相遇 另外如果m较小比如0,由x=pn/(a-b)(不考虑m/b) 则x只决定于a-b(只要改变p就可以得到x的合适的最小值，而p是决定于a-b的) T=(au+bu+av+w)x，在(a-b)一定的情况下，ab取值越小T越小

内存管理内幕[转载]- -

动态分配的选择、折衷和实现

Jonathan Bartlett
技术总监, New Media Worx
2004 年 11 月 29 日

本文将对 Linux™ 程序员可以使用的内存管理技术进行概述，虽然关注的重点是 C 语言，但同样也适用于其他语言。文中将为您提供如何管理内存的细节，然后将进一步展示如何手工管理内存，如何使用引用计数或者内存池来半手工地管理内存，以及如何使用垃圾收集自动管理内存。

为什么必须管理内存
内存管理是计算机编程最为基本的领域之一。在很多脚本语言中，您不必担心内存是如何管理的，这并不能使得内存管理的重要性有一点点降低。对实际编程来说，理解您的内存管理器的能力与局限性至关重要。在大部分系统语言中，比如 C 和 C++，您必须进行内存管理。本文将介绍手工的、半手工的以及自动的内存管理实践的基本概念。

追溯到在 Apple II 上进行汇编语言编程的时代，那时内存管理还不是个大问题。您实际上在运行整个系统。系统有多少内存，您就有多少内存。您甚至不必费心思去弄明白它有多少内存，因为每一台机器的内存数量都相同。所以，如果内存需要非常固定，那么您只需要选择一个内存范围并使用它即可。

不过，即使是在这样一个简单的计算机中，您也会有问题，尤其是当您不知道程序的每个部分将需要多少内存时。如果您的空间有限，而内存需求是变化的，那么您需要一些方法来满足这些需求：

• 确定您是否有足够的内存来处理数据。
• 从可用的内存中获取一部分内存。
• 向可用内存池（pool）中返回部分内存，以使其可以由程序的其他部分或者其他程序使用。

实现这些需求的程序库称为 分配程序（allocators），因为它们负责分配和回收内存。程序的动态性越强，内存管理就越重要，您的内存分配程序的选择也就更重要。让我们来了解可用于内存管理的不同方法，它们的好处与不足，以及它们最适用的情形。

C 风格的内存分配程序
C 编程语言提供了两个函数来满足我们的三个需求：

• malloc：该函数分配给定的字节数，并返回一个指向它们的指针。如果没有足够的可用内存，那么它返回一个空指针。
• free：该函数获得指向由 malloc 分配的内存片段的指针，并将其释放，以便以后的程序或操作系统使用（实际上，一些 malloc 实现只能将内存归还给程序，而无法将内存归还给操作系统）。

物理内存和虚拟内存
要理解内存在程序中是如何分配的，首先需要理解如何将内存从操作系统分配给程序。计算机上的每一个进程都认为自己可以访问所有的物理内存。显然，由于同时在运行多个程序，所以每个进程不可能拥有全部内存。实际上，这些进程使用的是 虚拟内存。

只是作为一个例子，让我们假定您的程序正在访问地址为 629 的内存。不过，虚拟内存系统不需要将其存储在位置为 629 的 RAM 中。实际上，它甚至可以不在 RAM 中 —— 如果物理 RAM 已经满了，它甚至可能已经被转移到硬盘上！由于这类地址不必反映内存所在的物理位置，所以它们被称为虚拟内存。操作系统维持着一个虚拟地址到物理地址的转换的表，以便计算机硬件可以正确地响应地址请求。并且，如果地址在硬盘上而不是在 RAM 中，那么操作系统将暂时停止您的进程，将其他内存转存到硬盘中，从硬盘上加载被请求的内存，然后再重新启动您的进程。这样，每个进程都获得了自己可以使用的地址空间，可以访问比您物理上安装的内存更多的内存。

在 32-位 x86 系统上，每一个进程可以访问 4 GB 内存。现在，大部分人的系统上并没有 4 GB 内存，即使您将 swap 也算上， 每个进程所使用的内存也肯定少于 4 GB。因此，当加载一个进程时，它会得到一个取决于某个称为 系统中断点（system break）的特定地址的初始内存分配。该地址之后是未被映射的内存 —— 用于在 RAM 或者硬盘中没有分配相应物理位置的内存。因此，如果一个进程运行超出了它初始分配的内存，那么它必须请求操作系统“映射进来（map in）”更多的内存。（映射是一个表示一一对应关系的数学术语 —— 当内存的虚拟地址有一个对应的物理地址来存储内存内容时，该内存将被映射。）

基于 UNIX 的系统有两个可映射到附加内存中的基本系统调用：

• brk： brk() 是一个非常简单的系统调用。还记得系统中断点吗？该位置是进程映射的内存边界。 brk() 只是简单地将这个位置向前或者向后移动，就可以向进程添加内存或者从进程取走内存。
• mmap： mmap()，或者说是“内存映像”，类似于 brk()，但是更为灵活。首先，它可以映射任何位置的内存，而不单单只局限于进程。其次，它不仅可以将虚拟地址映射到物理的 RAM 或者 swap，它还可以将它们映射到文件和文件位置，这样，读写内存将对文件中的数据进行读写。不过，在这里，我们只关心 mmap 向进程添加被映射的内存的能力。 munmap() 所做的事情与 mmap() 相反。

如您所见， brk() 或者 mmap() 都可以用来向我们的进程添加额外的虚拟内存。在我们的例子中将使用 brk()，因为它更简单，更通用。

实现一个简单的分配程序
如果您曾经编写过很多 C 程序，那么您可能曾多次使用过 malloc() 和 free()。不过，您可能没有用一些时间去思考它们在您的操作系统中是如何实现的。本节将向您展示 malloc 和 free 的一个最简化实现的代码，来帮助说明管理内存时都涉及到了哪些事情。

要试着运行这些示例，需要先 复制本代码清单，并将其粘贴到一个名为 malloc.c 的文件中。接下来，我将一次一个部分地对该清单进行解释。

在大部分操作系统中，内存分配由以下两个简单的函数来处理：

• void *malloc(long numbytes)：该函数负责分配 numbytes 大小的内存，并返回指向第一个字节的指针。
• void free(void *firstbyte)：如果给定一个由先前的 malloc 返回的指针，那么该函数会将分配的空间归还给进程的“空闲空间”。

malloc_init 将是初始化内存分配程序的函数。它要完成以下三件事：将分配程序标识为已经初始化，找到系统中最后一个有效内存地址，然后建立起指向我们管理的内存的指针。这三个变量都是全局变量：

        
int has_initialized = 0;

void *managed_memory_start;

void *last_valid_address;

      

如前所述，被映射的内存的边界（最后一个有效地址）常被称为系统中断点或者 当前中断点。在很多 UNIX® 系统中，为了指出当前系统中断点，必须使用 sbrk(0) 函数。 sbrk 根据参数中给出的字节数移动当前系统中断点，然后返回新的系统中断点。使用参数 0 只是返回当前中断点。这里是我们的 malloc 初始化代码，它将找到当前中断点并初始化我们的变量：

        
/* Include the sbrk function */

#include <unistd.h>

void malloc_init()

{

	/* grab the last valid address from the OS */

	last_valid_address = sbrk(0);


	/* we don't have any memory to manage yet, so
	 *just set the beginning to be last_valid_address
	 */

	managed_memory_start = last_valid_address;

	/* Okay, we're initialized and ready to go */

 	has_initialized = 1;

}

      

现在，为了完全地管理内存，我们需要能够追踪要分配和回收哪些内存。在对内存块进行了 free 调用之后，我们需要做的是诸如将它们标记为未被使用的等事情，并且，在调用 malloc 时，我们要能够定位未被使用的内存块。因此， malloc 返回的每块内存的起始处首先要有这个结构：

        
struct mem_control_block {

	int is_available;

	int size;

};

      

现在，您可能会认为当程序调用 malloc 时这会引发问题 —— 它们如何知道这个结构？答案是它们不必知道；在返回指针之前，我们会将其移动到这个结构之后，把它隐藏起来。这使得返回的指针指向没有用于任何其他用途的内存。那样，从调用程序的角度来看，它们所得到的全部是空闲的、开放的内存。然后，当通过 free() 将该指针传递回来时，我们只需要倒退几个内存字节就可以再次找到这个结构。

在讨论分配内存之前，我们将先讨论释放，因为它更简单。为了释放内存，我们必须要做的惟一一件事情就是，获得我们给出的指针，回退 sizeof(struct mem_control_block) 个字节，并将其标记为可用的。这里是对应的代码：

        
void free(void *firstbyte) {

	struct mem_control_block *mcb;

	/* Backup from the given pointer to find the
	 * mem_control_block
	 */

	mcb = firstbyte - sizeof(struct mem_control_block);

	/* Mark the block as being available */

	mcb->is_available = 1;

	/* That's It!  We're done. */

	return;
}

      

如您所见，在这个分配程序中，内存的释放使用了一个非常简单的机制，在固定时间内完成内存释放。分配内存稍微困难一些。以下是该算法的略述：

        

1. If our allocator has not been initialized, initialize it.

2. Add sizeof(struct mem_control_block) to the size requested.

3. start at managed_memory_start.

4. Are we at last_valid address?

5. If we are:

   A. We didn't find any existing space that was large enough
      -- ask the operating system for more and return that.

6. Otherwise:

   A. Is the current space available (check is_available from
      the mem_control_block)?

   B. If it is:

      i)   Is it large enough (check "size" from the
           mem_control_block)?

      ii)  If so:

           a. Mark it as unavailable

           b. Move past mem_control_block and return the
              pointer

      iii) Otherwise:

           a. Move forward "size" bytes

           b. Go back go step 4

   C. Otherwise:

      i)   Move forward "size" bytes

      ii)  Go back to step 4

      

我们主要使用连接的指针遍历内存来寻找开放的内存块。这里是代码：

        
void *malloc(long numbytes) {

	/* Holds where we are looking in memory */

	void *current_location;

	/* This is the same as current_location, but cast to a
	 * memory_control_block
	 */

	struct mem_control_block *current_location_mcb;

	/* This is the memory location we will return.  It will
	 * be set to 0 until we find something suitable
	 */

	void *memory_location;

	/* Initialize if we haven't already done so */

	if(! has_initialized) 	{

		malloc_init();

	}

	/* The memory we search for has to include the memory
	 * control block, but the users of malloc don't need
	 * to know this, so we'll just add it in for them.
	 */

	numbytes = numbytes + sizeof(struct mem_control_block);

	/* Set memory_location to 0 until we find a suitable
	 * location
	 */

	memory_location = 0;

	/* Begin searching at the start of managed memory */

	current_location = managed_memory_start;

	/* Keep going until we have searched all allocated space */

	while(current_location != last_valid_address)

	{

		/* current_location and current_location_mcb point
		 * to the same address.  However, current_location_mcb
		 * is of the correct type, so we can use it as a struct.
		 * current_location is a void pointer so we can use it
		 * to calculate addresses.
		 */

		current_location_mcb =

			(struct mem_control_block *)current_location;

		if(current_location_mcb->is_available)

		{

			if(current_location_mcb->size >= numbytes)

			{

				/* Woohoo!  We've found an open,
				 * appropriately-size location.
				 */

				/* It is no longer available */

				current_location_mcb->is_available = 0;

				/* We own it */

				memory_location = current_location;

				/* Leave the loop */

				break;

			}

		}

		/* If we made it here, it's because the Current memory
		 * block not suitable; move to the next one
		 */

		current_location = current_location +

			current_location_mcb->size;

	}

	/* If we still don't have a valid location, we'll
	 * have to ask the operating system for more memory
	 */

	if(! memory_location)

	{

		/* Move the program break numbytes further */

		sbrk(numbytes);

		/* The new memory will be where the last valid
		 * address left off
		 */

		memory_location = last_valid_address;

		/* We'll move the last valid address forward
		 * numbytes
		 */

		last_valid_address = last_valid_address + numbytes;

		/* We need to initialize the mem_control_block */

		current_location_mcb = memory_location;

		current_location_mcb->is_available = 0;

		current_location_mcb->size = numbytes;

	}

	/* Now, no matter what (well, except for error conditions),
	 * memory_location has the address of the memory, including
	 * the mem_control_block
	 */

	/* Move the pointer past the mem_control_block */

	memory_location = memory_location + sizeof(struct mem_control_block);

	/* Return the pointer */

	return memory_location;

 }

      

这就是我们的内存管理器。现在，我们只需要构建它，并在程序中使用它即可。

运行下面的命令来构建 malloc 兼容的分配程序（实际上，我们忽略了 realloc() 等一些函数，不过， malloc() 和 free() 才是最主要的函数）：

        
gcc -shared -fpic malloc.c -o malloc.so

      

该程序将生成一个名为 malloc.so 的文件，它是一个包含有我们的代码的共享库。

在 UNIX 系统中，现在您可以用您的分配程序来取代系统的 malloc()，做法如下：

        
LD_PRELOAD=/path/to/malloc.so

export LD_PRELOAD

      

LD_PRELOAD 环境变量使动态链接器在加载任何可执行程序之前，先加载给定的共享库的符号。它还为特定库中的符号赋予优先权。因此，从现在起，该会话中的任何应用程序都将使用我们的 malloc()，而不是只有系统的应用程序能够使用。有一些应用程序不使用 malloc()，不过它们是例外。其他使用 realloc() 等其他内存管理函数的应用程序，或者错误地假定 malloc() 内部行为的那些应用程序，很可能会崩溃。ash shell 似乎可以使用我们的新 malloc() 很好地工作。

如果您想确保 malloc() 正在被使用，那么您应该通过向函数的入口点添加 write() 调用来进行测试。

我们的内存管理器在很多方面都还存在欠缺，但它可以有效地展示内存管理需要做什么事情。它的某些缺点包括：

• 由于它对系统中断点（一个全局变量）进行操作，所以它不能与其他分配程序或者 mmap 一起使用。
• 当分配内存时，在最坏的情形下，它将不得不遍历 全部进程内存；其中可能包括位于硬盘上的很多内存，这意味着操作系统将不得不花时间去向硬盘移入数据和从硬盘中移出数据。
• 没有很好的内存不足处理方案（ malloc 只假定内存分配是成功的）。
• 它没有实现很多其他的内存函数，比如 realloc()。
• 由于 sbrk() 可能会交回比我们请求的更多的内存，所以在堆（heap）的末端会遗漏一些内存。
• 虽然 is_available 标记只包含一位信息，但它要使用完整的 4-字节 的字。
• 分配程序不是线程安全的。
• 分配程序不能将空闲空间拼合为更大的内存块。
• 分配程序的过于简单的匹配算法会导致产生很多潜在的内存碎片。
• 我确信还有很多其他问题。这就是为什么它只是一个例子!

其他 malloc 实现
malloc() 的实现有很多，这些实现各有优点与缺点。在设计一个分配程序时，要面临许多需要折衷的选择，其中包括：

• 分配的速度。
• 回收的速度。
• 有线程的环境的行为。
• 内存将要被用光时的行为。
• 局部缓存。
• 簿记（Bookkeeping）内存开销。
• 虚拟内存环境中的行为。
• 小的或者大的对象。
• 实时保证。

每一个实现都有其自身的优缺点集合。在我们的简单的分配程序中，分配非常慢，而回收非常快。另外，由于它在使用虚拟内存系统方面较差，所以它最适于处理大的对象。

还有其他许多分配程序可以使用。其中包括：

• Doug Lea Malloc：Doug Lea Malloc 实际上是完整的一组分配程序，其中包括 Doug Lea 的原始分配程序，GNU libc 分配程序和 ptmalloc。 Doug Lea 的分配程序有着与我们的版本非常类似的基本结构，但是它加入了索引，这使得搜索速度更快，并且可以将多个没有被使用的块组合为一个大的块。它还支持缓存，以便更快地再次使用最近释放的内存。 ptmalloc 是 Doug Lea Malloc 的一个扩展版本，支持多线程。在本文后面的 参考资料部分中，有一篇描述 Doug Lea 的 Malloc 实现的文章。
• BSD Malloc：BSD Malloc 是随 4.2 BSD 发行的实现，包含在 FreeBSD 之中，这个分配程序可以从预先确实大小的对象构成的池中分配对象。它有一些用于对象大小的 size 类，这些对象的大小为 2 的若干次幂减去某一常数。所以，如果您请求给定大小的一个对象，它就简单地分配一个与之匹配的 size 类。这样就提供了一个快速的实现，但是可能会浪费内存。在 参考资料部分中，有一篇描述该实现的文章。
• Hoard：编写 Hoard 的目标是使内存分配在多线程环境中进行得非常快。因此，它的构造以锁的使用为中心，从而使所有进程不必等待分配内存。它可以显著地加快那些进行很多分配和回收的多线程进程的速度。在 参考资料部分中，有一篇描述该实现的文章。

众多可用的分配程序中最有名的就是上述这些分配程序。如果您的程序有特别的分配需求，那么您可能更愿意编写一个定制的能匹配您的程序内存分配方式的分配程序。不过，如果不熟悉分配程序的设计，那么定制分配程序通常会带来比它们解决的问题更多的问题。要获得关于该主题的适当的介绍，请参阅 Donald Knuth 撰写的 The Art of Computer Programming Volume 1: Fundamental Algorithms 中的第 2.5 节“Dynamic Storage Allocation”（请参阅 参考资料中的链接）。它有点过时，因为它没有考虑虚拟内存环境，不过大部分算法都是基于前面给出的函数。

在 C++ 中，通过重载 operator new()，您可以以每个类或者每个模板为单位实现自己的分配程序。在 Andrei Alexandrescu 撰写的 Modern C++ Design 的第 4 章（“Small Object Allocation”）中，描述了一个小对象分配程序（请参阅 参考资料中的链接）。

基于 malloc() 的内存管理的缺点
不只是我们的内存管理器有缺点，基于 malloc() 的内存管理器仍然也有很多缺点，不管您使用的是哪个分配程序。对于那些需要保持长期存储的程序使用 malloc() 来管理内存可能会非常令人失望。如果您有大量的不固定的内存引用，经常难以知道它们何时被释放。生存期局限于当前函数的内存非常容易管理，但是对于生存期超出该范围的内存来说，管理内存则困难得多。而且，关于内存管理是由进行调用的程序还是由被调用的函数来负责这一问题，很多 API 都不是很明确。

因为管理内存的问题，很多程序倾向于使用它们自己的内存管理规则。C++ 的异常处理使得这项任务更成问题。有时好像致力于管理内存分配和清理的代码比实际完成计算任务的代码还要多！因此，我们将研究内存管理的其他选择。

半自动内存管理策略

引用计数
引用计数是一种 半自动（semi-automated）的内存管理技术，这表示它需要一些编程支持，但是它不需要您确切知道某一对象何时不再被使用。引用计数机制为您完成内存管理任务。

在引用计数中，所有共享的数据结构都有一个域来包含当前活动“引用”结构的次数。当向一个程序传递一个指向某个数据结构指针时，该程序会将引用计数增加 1。实质上，您是在告诉数据结构，它正在被存储在多少个位置上。然后，当您的进程完成对它的使用后，该程序就会将引用计数减少 1。结束这个动作之后，它还会检查计数是否已经减到零。如果是，那么它将释放内存。

这样做的好处是，您不必追踪程序中某个给定的数据结构可能会遵循的每一条路径。每次对其局部的引用，都将导致计数的适当增加或减少。这样可以防止在使用数据结构时释放该结构。不过，当您使用某个采用引用计数的数据结构时，您必须记得运行引用计数函数。另外，内置函数和第三方的库不会知道或者可以使用您的引用计数机制。引用计数也难以处理发生循环引用的数据结构。

要实现引用计数，您只需要两个函数 —— 一个增加引用计数，一个减少引用计数并当计数减少到零时释放内存。

一个示例引用计数函数集可能看起来如下所示：

        
/* Structure Definitions*/

/* Base structure that holds a refcount */

struct refcountedstruct

{

	int refcount;

}

/* All refcounted structures must mirror struct
 * refcountedstruct for their first variables
 */

/* Refcount maintenance functions */

/* Increase reference count */

void REF(void *data)

{

	struct refcountedstruct *rstruct;

	rstruct = (struct refcountedstruct *) data;

	rstruct->refcount++;

}

/* Decrease reference count */

void UNREF(void *data)

{

	struct refcountedstruct *rstruct;

	rstruct = (struct refcountedstruct *) data;

	rstruct->refcount--;

	/* Free the structure if there are no more users */

	if(rstruct->refcount == 0)

	{

		free(rstruct);

	}

}

      

REF 和 UNREF 可能会更复杂，这取决于您想要做的事情。例如，您可能想要为多线程程序增加锁，那么您可能想扩展 refcountedstruct，使它同样包含一个指向某个在释放内存之前要调用的函数的指针（类似于面向对象语言中的析构函数 —— 如果您的结构中包含这些指针，那么这是 必需的）。

当使用 REF 和 UNREF 时，您需要遵守这些指针的分配规则：

• UNREF 分配前左端指针（left-hand-side pointer）指向的值。
• REF 分配后左端指针（left-hand-side pointer）指向的值。

在传递使用引用计数的结构的函数中，函数需要遵循以下这些规则：

• 在函数的起始处 REF 每一个指针。
• 在函数的结束处 UNREF 第一个指针。

以下是一个使用引用计数的生动的代码示例：

        
/* EXAMPLES OF USAGE */


/* Data type to be refcounted */

struct mydata

{

	int refcount; /* same as refcountedstruct */

	int datafield1; /* Fields specific to this struct */

	int datafield2;

	/* other declarations would go here as appropriate */

};


/* Use the functions in code */

void dosomething(struct mydata *data)

{

	REF(data);

	/* Process data */

	/* when we are through */

	UNREF(data);

}


struct mydata *globalvar1;

/* Note that in this one, we don't decrease the
 * refcount since we are maintaining the reference
 * past the end of the function call through the
 * global variable
 */

void storesomething(struct mydata *data)

{

	REF(data); /* passed as a parameter */

	globalvar1 = data;

	REF(data); /* ref because of Assignment */

	UNREF(data); /* Function finished */

}

      

由于引用计数是如此简单，大部分程序员都自已去实现它，而不是使用库。不过，它们依赖于 malloc 和 free 等低层的分配程序来实际地分配和释放它们的内存。

在 Perl 等高级语言中，进行内存管理时使用引用计数非常广泛。在这些语言中，引用计数由语言自动地处理，所以您根本不必担心它，除非要编写扩展模块。由于所有内容都必须进行引用计数，所以这会对速度产生一些影响，但它极大地提高了编程的安全性和方便性。以下是引用计数的益处：

• 实现简单。
• 易于使用。
• 由于引用是数据结构的一部分，所以它有一个好的缓存位置。

不过，它也有其不足之处：

• 要求您永远不要忘记调用引用计数函数。
• 无法释放作为循环数据结构的一部分的结构。
• 减缓几乎每一个指针的分配。
• 尽管所使用的对象采用了引用计数，但是当使用异常处理（比如 try 或 setjmp()/ longjmp()）时，您必须采取其他方法。
• 需要额外的内存来处理引用。
• 引用计数占用了结构中的第一个位置，在大部分机器中最快可以访问到的就是这个位置。
• 在多线程环境中更慢也更难以使用。

C++ 可以通过使用 智能指针（smart pointers）来容忍程序员所犯的一些错误，智能指针可以为您处理引用计数等指针处理细节。不过，如果不得不使用任何先前的不能处理智能指针的代码（比如对 C 库的联接），实际上，使用它们的后果通实比不使用它们更为困难和复杂。因此，它通常只是有益于纯 C++ 项目。如果您想使用智能指针，那么您实在应该去阅读 Alexandrescu 撰写的 Modern C++ Design 一书中的“Smart Pointers”那一章。

内存池
内存池是另一种半自动内存管理方法。内存池帮助某些程序进行自动内存管理，这些程序会经历一些特定的阶段，而且每个阶段中都有分配给进程的特定阶段的内存。例如，很多网络服务器进程都会分配很多针对每个连接的内存 —— 内存的最大生存期限为当前连接的存在期。Apache 使用了池式内存（pooled memory），将其连接拆分为各个阶段，每个阶段都有自己的内存池。在结束每个阶段时，会一次释放所有内存。

在池式内存管理中，每次内存分配都会指定内存池，从中分配内存。每个内存池都有不同的生存期限。在 Apache 中，有一个持续时间为服务器存在期的内存池，还有一个持续时间为连接的存在期的内存池，以及一个持续时间为请求的存在期的池，另外还有其他一些内存池。因此，如果我的一系列函数不会生成比连接持续时间更长的数据，那么我就可以完全从连接池中分配内存，并知道在连接结束时，这些内存会被自动释放。另外，有一些实现允许注册 清除函数（cleanup functions），在清除内存池之前，恰好可以调用它，来完成在内存被清理前需要完成的其他所有任务（类似于面向对象中的析构函数）。

要在自己的程序中使用池，您既可以使用 GNU libc 的 obstack 实现，也可以使用 Apache 的 Apache Portable Runtime。GNU obstack 的好处在于，基于 GNU 的 Linux 发行版本中默认会包括它们。Apache Portable Runtime 的好处在于它有很多其他工具，可以处理编写多平台服务器软件所有方面的事情。要深入了解 GNU obstack 和 Apache 的池式内存实现，请参阅 参考资料部分中指向这些实现的文档的链接。

下面的假想代码列表展示了如何使用 obstack：

        
#include <obstack.h>

#include <stdlib.h>

/* Example code listing for using obstacks */

/* Used for obstack macros (xmalloc is
   a malloc function that exits if memory
   is exhausted */

#define obstack_chunk_alloc xmalloc

#define obstack_chunk_free free

/* Pools */

/* Only permanent allocations should go in this pool */

struct obstack *global_pool;

/* This pool is for per-connection data */

struct obstack *connection_pool;

/* This pool is for per-request data */

struct obstack *request_pool;

void allocation_failed()

{

	exit(1);

}

int main()

{

	/* Initialize Pools */

	global_pool = (struct obstack *)

		xmalloc (sizeof (struct obstack));

	obstack_init(global_pool);

	connection_pool = (struct obstack *)

		xmalloc (sizeof (struct obstack));

	obstack_init(connection_pool);

	request_pool = (struct obstack *)

		xmalloc (sizeof (struct obstack));

	obstack_init(request_pool);

	/* Set the error handling function */

	obstack_alloc_failed_handler = &allocation_failed;

	/* Server main loop */

	while(1)

	{

		wait_for_connection();

		/* We are in a connection */

		while(more_requests_available())

		{

			/* Handle request */

			handle_request();

			/* Free all of the memory allocated

			 * in the request pool

			 */

			obstack_free(request_pool, NULL);

		}

		/* We're finished with the connection, time

		 * to free that pool

		 */

		obstack_free(connection_pool, NULL);

	}

}

int handle_request()

{

	/* Be sure that all object allocations are allocated
	 * from the request pool
	 */

	int bytes_i_need = 400;

	void *data1 = obstack_alloc(request_pool, bytes_i_need);

	/* Do stuff to process the request */

	/* return */

	return 0;

}

      

基本上，在操作的每一个主要阶段结束之后，这个阶段的 obstack 会被释放。不过，要注意的是，如果一个过程需要分配持续时间比当前阶段更长的内存，那么它也可以使用更长期限的 obstack，比如连接或者全局内存。传递给 obstack_free() 的 NULL 指出它应该释放 obstack 的全部内容。可以用其他的值，但是它们通常不怎么实用。

使用池式内存分配的益处如下所示：

• 应用程序可以简单地管理内存。
• 内存分配和回收更快，因为每次都是在一个池中完成的。分配可以在 O(1) 时间内完成，释放内存池所需时间也差不多（实际上是 O(n) 时间，不过在大部分情况下会除以一个大的因数，使其变成 O(1)）。
• 可以预先分配错误处理池（Error-handling pools），以便程序在常规内存被耗尽时仍可以恢复。
• 有非常易于使用的标准实现。

池式内存的缺点是：

• 内存池只适用于操作可以分阶段的程序。
• 内存池通常不能与第三方库很好地合作。
• 如果程序的结构发生变化，则不得不修改内存池，这可能会导致内存管理系统的重新设计。
• 您必须记住需要从哪个池进行分配。另外，如果在这里出错，就很难捕获该内存池。

垃圾收集
垃圾收集（Garbage collection）是全自动地检测并移除不再使用的数据对象。垃圾收集器通常会在当可用内存减少到少于一个具体的阈值时运行。通常，它们以程序所知的可用的一组“基本”数据 —— 栈数据、全局变量、寄存器 —— 作为出发点。然后它们尝试去追踪通过这些数据连接到每一块数据。收集器找到的都是有用的数据；它没有找到的就是垃圾，可以被销毁并重新使用这些无用的数据。为了有效地管理内存，很多类型的垃圾收集器都需要知道数据结构内部指针的规划，所以，为了正确运行垃圾收集器，它们必须是语言本身的一部分。

收集器的类型

• 复制（copying）： 这些收集器将内存存储器分为两部分，只允许数据驻留在其中一部分上。它们定时地从“基本”的元素开始将数据从一部分复制到另一部分。内存新近被占用的部分现在成为活动的，另一部分上的所有内容都认为是垃圾。另外，当进行这项复制操作时，所有指针都必须被更新为指向每个内存条目的新位置。因此，为使用这种垃圾收集方法，垃圾收集器必须与编程语言集成在一起。
• 标记并清理（Mark and sweep）：每一块数据都被加上一个标签。不定期的，所有标签都被设置为 0，收集器从“基本”的元素开始遍历数据。当它遇到内存时，就将标签标记为 1。最后没有被标记为 1 的所有内容都认为是垃圾，以后分配内存时会重新使用它们。
• 增量的（Incremental）：增量垃圾收集器不需要遍历全部数据对象。因为在收集期间的突然等待，也因为与访问所有当前数据相关的缓存问题（所有内容都不得不被页入（page-in）），遍历所有内存会引发问题。增量收集器避免了这些问题。
• 保守的（Conservative）：保守的垃圾收集器在管理内存时不需要知道与数据结构相关的任何信息。它们只查看所有数据类型，并假定它们 可以全部都是指针。所以，如果一个字节序列可以是一个指向一块被分配的内存的指针，那么收集器就将其标记为正在被引用。有时没有被引用的内存会被收集，这样会引发问题，例如，如果一个整数域中包含一个值，该值是已分配内存的地址。不过，这种情况极少发生，而且它只会浪费少量内存。保守的收集器的优势是，它们可以与任何编程语言相集成。

Hans Boehm 的保守垃圾收集器是可用的最流行的垃圾收集器之一，因为它是免费的，而且既是保守的又是增量的，可以使用 --enable-redirect-malloc 选项来构建它，并且可以将它用作系统分配程序的简易替代者（drop-in replacement）（用 malloc/ free 代替它自己的 API）。实际上，如果这样做，您就可以使用与我们在示例分配程序中所使用的相同的 LD_PRELOAD 技巧，在系统上的几乎任何程序中启用垃圾收集。如果您怀疑某个程序正在泄漏内存，那么您可以使用这个垃圾收集器来控制进程。在早期，当 Mozilla 严重地泄漏内存时，很多人在其中使用了这项技术。这种垃圾收集器既可以在 Windows® 下运行，也可以在 UNIX 下运行。

垃圾收集的一些优点：

• 您永远不必担心内存的双重释放或者对象的生命周期。
• 使用某些收集器，您可以使用与常规分配相同的 API。

其缺点包括：

• 使用大部分收集器时，您都无法干涉何时释放内存。
• 在多数情况下，垃圾收集比其他形式的内存管理更慢。
• 垃圾收集错误引发的缺陷难于调试。
• 如果您忘记将不再使用的指针设置为 null，那么仍然会有内存泄漏。

结束语
一切都需要折衷：性能、易用、易于实现、支持线程的能力等，这里只列出了其中的一些。为了满足项目的要求，有很多内存管理模式可以供您使用。每种模式都有大量的实现，各有其优缺点。对很多项目来说，使用编程环境默认的技术就足够了，不过，当您的项目有特殊的需要时，了解可用的选择将会有帮助。下表对比了本文中涉及的内存管理策略。

表 1. 内存分配策略的对比

/* Take from the IBM development formum*/

/* Include the sbrk function */
#include <unistd.h>

int has_initialized = 0;
void *managed_memory_start;
void *last_valid_address;

void malloc_init()
{
/* grab the last valid address from the OS */ 
last_valid_address = sbrk(0);    

/* we don't have any memory to manage yet, so
  *just set the beginning to be last_valid_address
  */ 
managed_memory_start = last_valid_address;    

/* Okay, we're initialized and ready to go */
  has_initialized = 1;  
}

struct mem_control_block {
int is_available;
int size;
};

void free(void *firstbyte) {
struct mem_control_block *mcb; 

/* Backup from the given pointer to find the
  * mem_control_block
  */
mcb = firstbyte - sizeof(struct mem_control_block);  
/* Mark the block as being available */
mcb->is_available = 1;   
/* That's It!  We're done. */
return;  
} 

void *malloc(long numbytes) {
/* Holds where we are looking in memory */
void *current_location;

/* This is the same as current_location, but cast to a
  * memory_control_block
  */
struct mem_control_block *current_location_mcb; 

/* This is the memory location we will return.  It will
  * be set to 0 until we find something suitable
  */ 
void *memory_location; 

/* Initialize if we haven't already done so */
if(! has_initialized)  {
  malloc_init();
}

/* The memory we search for has to include the memory
  * control block, but the user of malloc doesn't need
  * to know this, so we'll just add it in for them.
  */
numbytes = numbytes + sizeof(struct mem_control_block); 

/* Set memory_location to 0 until we find a suitable
  * location
  */
memory_location = 0; 

/* Begin searching at the start of managed memory */
current_location = managed_memory_start; 

/* Keep going until we have searched all allocated space */
while(current_location != last_valid_address) 
{
  /* current_location and current_location_mcb point
   * to the same address.  However, current_location_mcb
   * is of the correct type so we can use it as a struct.
   * current_location is a void pointer so we can use it
   * to calculate addresses.
   */
  current_location_mcb =
   (struct mem_control_block *)current_location;

  if(current_location_mcb->is_available)
  {
   if(current_location_mcb->size >= numbytes)
   {
    /* Woohoo!  We've found an open,
     * appropriately-size location. 
     */

    /* It is no longer available */
    current_location_mcb->is_available = 0;

    /* We own it */
    memory_location = current_location;

    /* Leave the loop */
    break;
   }
  }

  /* If we made it here, it's because the Current memory
   * block not suitable, move to the next one
   */
  current_location = current_location +
   current_location_mcb->size;
}

/* If we still don't have a valid location, we'll
  * have to ask the operating system for more memory
  */
if(! memory_location)
{
  /* Move the program break numbytes further */
  sbrk(numbytes);

  /* The new memory will be where the last valid
   * address left off
   */
  memory_location = last_valid_address;

  /* We'll move the last valid address forward
   * numbytes
   */
  last_valid_address = last_valid_address + numbytes;

  /* We need to initialize the mem_control_block */
  current_location_mcb = memory_location;
  current_location_mcb->is_available = 0;
  current_location_mcb->size = numbytes;
}

/* Now, no matter what (well, except for error conditions),
  * memory_location has the address of the memory, including
  * the mem_control_block
  */

/* Move the pointer past the mem_control_block */
memory_location = memory_location + sizeof(struct mem_control_block);

/* Return the pointer */
return memory_location;
}