画笔，画刷等资源继承resource
为了避免发生资源泄露和resource的管理
设计ResourceManager类，负责资源的创建，加载和卸载以及删除

两个抽象类 Resource 和 ResourceManager
两个具体类 ConcreateResource 和 ConcreateResourceManager
分别派生于上面的抽象类

以上设计是看了 OGRE 游戏引擎的资源管理部分，
对它的资源管理类ResourceManager不是很理解

resource 派生了pen,brush等类
pen类可以来自文件，也可以自己创建SubPen 添加到SubPenList中

ResourceManager 负责创建资源Resource
1. 如果我在抽象的 ResourceManager 声明 createRes函数，并返回基类resource
势必会要强制转换，然后在用到具体的Resource时候又要转换回来

2. 如果我在具体类 ConcreateResourceManager 声明 createConcreateRes函数
那么就白费了我应用设计模式设计这么多类

// abstract class for resource
class Resource{
public:
 // standard constructor
  Resource(const string& name, const string& group)
 :mName(name),mGroup(group){}
  ~Resource(){}
protected:
 // prevent default construct
  Resource():mName(""),mGroup(""){}
  string mName;
  string mGroup;
  static unsigned long mHandle;
};

// subclass of resource
// concreateResource such as PEN
class Pen:
 public Resource{
 Pen(const string& name, const string& group)
  :Resource(name,group){}
  ~Pen(){}

  void loadfromFile(string& filename);

// add into vector
  void addSubPen(SubPen* sub){
     mSubPenList.push_back(sub);
}
public:
typedef std::vector<SubPen> SubPenList;
SubPenList mSubPenList;

};
class
// abstract class for resource manager
class ResourceManager{
public:
  ResourceManager(){}
  ~ResourceManager(){}
public:
// here , I cannot understand OGRE degsin
  Resource* createRes(const string& name,const string& group);
 // resource map
　typedef std::map<string,Resource*> ResourceMap;
   ResourceMap mResources;

};

// subclass ResourceManager
class ConcreateResourceManager
 :public ResourceManager
{
 ConcreateResourceManager(){}
 ~ConcreateResourceManager(){}

      // how can design here!!
       Pen* createPen(const string& name,const string& group){}
}

FeedBack:

        void(*fp)();

　　fp 是一个典型的函数指针，用于指向无参数，无返回值的函数。

        void(*fp2)(int);

　　fp2 也是一个函数指针，用于指向有一个整型参数，无返回值的函数。
　　当然，有经验人士一般都会建议使用typedef来定义函数指针的类型，如：

        typedef void(* FP)();
        FP fp3; // 和上面的fp一样的定义。

　　函数指针之所以让初学者畏惧，最主要的原因是它的括号太多了；某些用途的函数指针，往往会让人陷在括号堆中出不来，这里就不举例了，因为不是本文讨论的范围；typedef 方法可以有效的减少括号的数量，以及理清层次，所以受到推荐。本文暂时只考虑简单的函数指针，因此暂不用到typedef。

　　假如有如下两个函数：

  void f1()
  {
      std::cout << "call f " << std::endl;
  }
  
  void f2(int a)
  {
      std::cout << "call f2( " << a << " )" << std::endl;
  }

　　现在需要通过函数指针来调用，我们需要给指针指定函数：

  fp = &f1; // 也可以用：fp = f1;
  fp2= &f2; // 也可以用：fp2= f2;
  void (*fp3)() = &f1; // 也可以用：void (*fp3)() = f1;  
  //调用时如下：
  fp(); // 或 (*fp)();
  fp2(1); // 或 (*fp2)(1);
  fp3();  // 或 (*fp3)();

　　对于此两种调用方法，效果完全一样，我推荐用前一种。后一种不仅仅是多打了键盘，而且也损失了一些灵活性。这里暂且不说它。
  
　　C++强调类型安全。也就是说，不同类型的变量是不能直接赋值的，否则轻则警告，重则报错。这是一个很有用的特性，常常能帮我们找到问题。因此，有识之士认为，C++中的任何一外警告都不能忽视。甚至有人提出，编译的时候不能出现任何警告信息，也就是说，警告应该当作错误一样处理。
  
　　比如，我们把f1赋值给fp2，那么C++编译器(vc7.1)就会报错：

  fp2 = &f1; // error C2440: “=” : 无法从“void (__cdecl *)(void)”转换为“void (__cdecl *)(int)”
  fp1 = &f1; // OK

　　这样，编译器可以帮我们找出编码上的错误，节省了我们的排错时间。
  
　　考虑一下C++标准模板库的sort函数：

  // 快速排序函数
  template<typename RandomAccessIterator, typename BinaryPredicate>
     void sort(
        RandomAccessIterator _First, // 需排序数据的第一个元素位置
        RandomAccessIterator _Last,  // 需排序数据的最后一个元素位置（不参与排序）
        BinaryPredicate _Comp     // 排序使用的比较算法(可以是函数指针、函数对象等)
     );

　　比如，我们有一个整型数组：

  int n[5] = {3,2,1,8,9};

　　要对它进行升序排序，我们需定义一个比较函数：

  bool less(int a, int b)
  {
      return a < b; 
  }

　　然后用：

  sort(n, n+5, less);

　　要是想对它进行降序排序，我们只要换一个比较函数就可以了。C/C++的标准模板已经提供了less和great函数，因此我们可以直接用下面的语句来比较：  

  sort(n, n+5, great);

　　这样，不需要改变sort函数的定义，就可以按任意方法进行排序，是不是很灵活？  
　　这种用法以C++的标准模板库(STL)中非常流行。另外，操作系统中也经常使用回调(CallBack)函数，实际上，所谓回调函数，本质就是函数指针。

　　看起来很简单吧，这是最普通的C语言指针的用法。本来这是一个很美妙的事情，但是当C++来临时，世界就开始变了样。
　　假如，用来进行sort的比较函数是某个类的成员，那又如何呢？

数据指针	T *
成员数据指针	T::*
函数指针	R (*)(...)
成员函数指针	R (T::*)(...)

　　尽管C++中仍然有万能指针void*，但它却属于被批斗的对象，而且再也不能“万能”了。它不能转换成成员指针。

　　这样一来，C++的指针就变得很尴尬：我们需要一种指针能够指向同一类型的数据，不管这个数据是普通数据，还是成员数据；我们更需要一种指针能够指向同一类型的函数，不管这个函数是静态函数，还是成员函数。但是没有，至少从现在的C++标准中，还没有看到。
　
沐枫网志 C++指针探讨(三)成员函数指针

　　自从有了类，我们开始按照　数据＋操作　的方式来组织数据结构；自从有了模板，我们又开始把 数据 和 算法 分离，以便重用，实在够折腾人的。但不管怎么折腾，现在大多数函数都不再单身，都嫁给了类，进了围城。可是我们仍然需要能够自由调用这些成员函数。
　　考虑一下windows下的定时调用。SetTimer函数的原型是这样的：

UINT_PTR SetTimer(
    HWND hWnd,
    UINT_PTR nIDEvent,
    UINT uElapse,
    TIMERPROC lpTimerFunc
);

uintptr_t _beginthread( 
   void( *start_address )( void * ),
   unsigned stack_size,
   void *arglist 
);

class mythread
{
  public:
    static void doit(void* pThis)
    {
　　　　((mythread*)pThis)->doit();
    }
    void doit(){}
};

main()
{
  
  mythread* pmt = new mythread;
  _beginthread(&mythread::doit, 0, (void*)pmt);
  
}

　　但是显然，C++程序员肯定不会因此而满足。这里头有许多被C++批判的不安定因素。它使用了C++中被认为不安全的类型转换，不安全的void*指针，等等等等。但这是系统为C语言留下的调用接口，这也就认了。那么假如，我们就在C++程序中如何来调用成员函数指针呢？
　　如下例，我们打算对vector中的所有类调用其指定的成员函数：

#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
using namespace std;

class A
{
    int value;
public:
    A(int v){value = v;}
    void doit(){ cout << value << endl;};
    static void call_doit(A& rThis)
    {
        rThis.doit();
    }
};


int main()
{
    vector<A> va;
    va.push_back(A(1));
    va.push_back(A(2));
    va.push_back(A(3));
    va.push_back(A(4));
    //方法1:
    //for_each(va.begin(), va.end(), &A::doit); //error
    //方法2:
    for_each(va.begin(), va.end(), &A::call_doit);
    //方法3:
    for_each(va.begin(), va.end(), mem_fun_ref<void, A>(&A::doit));

    system("Pause");

    return 0;
}

　　方法1，编译不能通过。for_each只允许具有一个参数的函数指针或函数对象，哪怕A::doit默认有一个this指针参数也不行。不是for_each没考虑到这一点，而是根本做不到！
　　方法2，显然是受到了beginthread的启发，使用一个静态函数来转调用，哈哈成功了。但是不爽！这不是C++。
　　方法3，呼，好不容易啊，终于用mem_fun_ref包装成功了成员函数指针。
　　似乎方法3不错，又是类型安全的，又可以通用－－慢着，首先，它很丑，哪有调用普通C函数指针那么漂亮啊（见方法2），用了一大串包装，又是尖括号又是圆括号，还少不了&号！其次，它只能包装不超过一个参数的函数！尽管它在for_each中够用了，但是你要是想用在超过一个参数的场合，那只有一句话：不可能的任务。

　　是的，在标准C++中，这是不可能的任务。但事情并不总是悲观的，至少有许多第三方库提供了超越mem_fun的包装。如boost::function等等。但是它也有限制：它所支持的参数仍然是有限的，只有十多个，尽管够你用的了；同样，它也是丑陋的，永远不要想它能够简单的用&来搞定。

　　也许，以失去美丽的代价，来换取质量上的保证，这也是C++对于函数指针的一种无奈吧……

　　期待C++0x版本。它通过可变模板参数，能够让mem_fun的参数达到无限个……

－－－－－－－－
   BTW: C++Builder扩展了一个关键字 closure ，允许成员函数指针如同普通函数指针一样使用。也许C++0x能考虑一下……

按照面向过程的基本原则，划分系统功能模块、模块细分到函数、生成系统整体的结构模型，似乎在整个过程中没有任何东西可以用来提供系统扩展，其实解决的方法还是有的，这根救命稻草就是回调机制。

一谈到回调机制，当然就少不了我们的主角：系统API(通常都是)和回调函数，这两者缺一不可。其实回调的基本思想就是由系统给我们提供一些接口，也就是常使用的API，这种函数可以将某个其他函数的地址作为其参数之一，而且可以利用该地址对这个函数进行调用，而被调用的函数就是我们通常所说的回调函数了。
下面给个回调函数使用的小例子：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
//相当于我们提到的系统API
mainFunc( void*  userFunc )//当然参数不会这么简单，只是模拟
{
 while (...)
 {
  printf("ok!");
                //调用回调函数了
  if (userFunc!=NULL) 
   userFunc();
 }
}
可以看出MainFunc可以根据函数userFunc的地址调用它。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
这样使用者只需要定义一个函数：void myFunc()，然后按照mainFunc(&myFunc)(&只表示传递的是函数的地址，无具体含义)，就可以让我们的mainFunc来调用myFunc从而实现相应的功能，这样当然可以完成我们预期的目的－扩展现有系统。

在windows系统中，支持这种回调机制的系统API不占少数，像实现ListControl排序的SortItem()函数，还有操作Font使用的函数EnumFontFamilies()都有提供这种回调机制，使得我们的用户有机会添加自己期望的功能实现。当然，使用回调函数并不是一个轻松的事情，如果我们的系统中存在了大量的回调函数是很难管理的，这个就与系统中存在大量全局变量一样，出现多个函数争相访问同一个变量我们就很难使用简单的逻辑来处理，容易陷入混乱，因此，尽管回调机制可以在某种程度上达到我们的目的，但切不可乱加使用，不然后果很难预料。

当然至于详细的回调函数实现，还需要大家潜心研究，这里我只是总结一下：
1 回调函数是由开发者按照一定的原型进行定义的函数(每个回调函数都必须遵循这个原型来设计)

例如：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
BOOL CALLBACK DialogProc(
    
     HWND hwndDlg, // handle of dialog box
     UINT uMsg, // message
     WPARAM wParam, // first message parameter
     LPARAM lParam // second message parameter
     );
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
说明：
回调函数必须有关键词 CALLBACK
回调函数本身必须是全局函数或者静态函数，不可定义为某个特定的类的成员函数

2 回调函数并不由开发者直接调用执行(只是使用系统接口API函数作为起点)
3 回调函数通常作为参数传递给系统API，由该API来调用
4 回调函数可能被系统API调用一次，也可能被循环调用多次(SortItem就是自调用)

最后说句题外话，其实windows系统中还有另一种机制－消息机制，也是一个比较不错的工具，能够为很多实际的问题提供解决方法，这个以后再总结了。

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

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

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

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

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

      (4)由于静态成员函数没有this指针，所以就差不多等同于nonmember函数，结果就
产生了一个意想不到的好处：成为一个callback函数，使得我们得以将C++和C-based X W
indow系统结合，同时也成功的应用于线程函数身上。
      (5)static并没有增加程序的时空开销，相反她还缩短了子类对父类静态成员的访问
时间，节省了子类的内存空间。
      (6)静态数据成员在<定义或说明>时前面加关键字static。
      (7)静态数据成员是静态存储的，所以必须对它进行初始化。
      (8)静态成员初始化与一般数据成员初始化不同:
      初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆；
      初始化时不加该成员的访问权限控制符private，public等；
           初始化时使用作用域运算符来标明它所属类；
           所以我们得出静态数据成员初始化的格式：
         <数据类型><类名>::<静态数据成员名>=<值>
      (9)为了防止父类的影响，可以在子类定义一个与父类相同的静态变量，以屏蔽父类的影响。这里有一点需要注意：我们说静态成员为父类和子类共享，但我们有重复定义了静态成员，这会不会引起错误呢？不会，我们的编译器采用了一种绝妙的手法：name-mangling 用以生成唯一的标志。

（感谢西安软件园的王先生为我指出错误，感谢网友backer帮助我找出正确的答案。）

在光盘VC02中，在介绍构造函数时，我说：“构造函数最重要的作用是创建对象本身，对象内存的分配由构造函数来完成的”，这句话是错的，对象内存的分配和构造函数没有关系，对象内存的分配是由编译器来完成的，构造函数的作用是对对象本身做初始化工作，也就是给用户提供初始化类中成员变量的一种方式，在类对象有虚表的情况下，构造函数还对虚表进行初始化。

另外，我说：“C++又规定，如果一个类没有提供任何的构造函数，则C++提供一个默认的构造函数（由C++编译器提供）”，这句话也是错误的，正确的是：

如果一个类中没有定义任何的构造函数，那么编译器只有在以下三种情况，才会提供默认的构造函数：
1、如果类有虚拟成员函数或者虚拟继承父类（即有虚拟基类）时；
2、如果类的基类有构造函数（可以是用户定义的构造函数，或编译器提供的默认构造函数）；
3、在类中的所有非静态的对象数据成员，它们对应的类中有构造函数（可以是用户定义的构造函数，或编译器提供的默认构造函数）。

――即VC++视频第三课this指针详细说明

作者：孙鑫 时间：2006年1月12日星期四

要更好地理解C++的多态性，我们需要弄清楚函数覆盖的调用机制，因此，首先我们介绍一下函数的覆盖。

1.   函数的覆盖

我们先看一个例子：

#include <iostream.h>

class animal

{

public:

       void sleep()

       {

              cout<<"animal sleep"<<endl;

       }

       void breathe()

       {

              cout<<"animal breathe"<<endl;

       }

};

class fish:public animal

{

public:

       void breathe()

       {

              cout<<"fish bubble"<<endl;

       }

};

void main()

{

       fish fh;

       animal *pAn=&fh;

       pAn->breathe();

       注意，在例1-1的程序中没有定义虚函数。考虑一下例1-1的程序执行的结果是什么？

       答案是输出：animal breathe

       在类fish中重写了breathe()函数，我们可以称为函数的覆盖。在main()函数中首先定义了一个fish对象fh，接着定义了一个指向animal的指针变量pAn，将fh的地址赋给了指针变量pAn，然后利用该变量调用pAn->breathe()。许多学员往往将这种情况和C++的多态性搞混淆，认为fh实际上是fish类的对象，应该是调用fish类的breathe()，输出“fish bubble”，然后结果却不是这样。下面我们从两个方面来讲述原因。

1、  编译的角度

C++编译器在编译的时候，要确定每个对象调用的函数的地址，这称为早期绑定（early binding），当我们将fish类的对象fh的地址赋给pAn时，C++编译器进行了类型转换，此时C++编译器认为变量pAn保存就是animal对象的地址。当在main()函数中执行pAn->breathe()时，调用的当然就是animal对象的breathe函数。

2、  内存模型的角度

我们给出了fish对象内存模型，如下图所示：

图1- 1 fish类对象的内存模型

我们构造fish类的对象时，首先要调用animal类的构造函数去构造animal类的对象，然后才调用fish类的构造函数完成自身部分的构造，从而拼接出一个完整的fish对象。当我们将fish类的对象转换为animal类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是图1-1中的“animal的对象所占内存”。那么当我们利用类型转换后的对象指针去调用它的方法时，当然也就是调用它所在的内存中的方法。因此，出现图2.13所示的结果，也就顺理成章了。

编译器在编译的时候，发现animal类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表（即vtable），该表是一个一维数组，在这个数组中存放每个虚函数的地址。对于例1-2的程序，animal和fish类都包含了一个虚函数breathe()，因此编译器会为这两个类都建立一个虚表，如下图所示：

图1- 2 animal类和fish类的虚表

       那么如何定位虚表呢？编译器另外还为每个类提供了一个虚表指针（即vptr），这个指针指向了对象的虚表。在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向所属类的虚表，从而在调用虚函数时，就能够找到正确的函数。对于例1-2的程序，由于pAn实际指向的对象类型是fish，因此vptr指向的fish类的vtable，当调用pAn->breathe()时，根据虚表中的函数地址找到的就是fish类的breathe()函数。

正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。那么虚表指针在什么时候，或者说在什么地方初始化呢？

答案是在构造函数中进行虚表的创建和虚表指针的初始化。还记得构造函数的调用顺序吗，在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否后还有继承者，它初始化父类的虚表指针，该虚表指针指向父类的虚表。当执行子类的构造函数时，子类的虚表指针被初始化，指向自身的虚表。对于例2-2的程序来说，当fish类的fh对象构造完毕后，其内部的虚表指针也就被初始化为指向fish类的虚表。在类型转换后，调用pAn->breathe()，由于pAn实际指向的是fish类的对象，该对象内部的虚表指针指向的是fish类的虚表，因此最终调用的是fish类的breathe()函数。

要注意：对于虚函数调用来说，每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类的虚表。所以在程序中，不管你的对象类型如何转换，但该对象内部的虚表指针是固定的，所以呢，才能实现动态的对象函数调用，这就是C++多态性实现的原理。

总结（基类有虚函数）：

1、  每一个类都有虚表。

2、  虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现。如果基类3个虚函数，那么基类的虚表中就有三项（虚函数地址），派生类也会有虚表，至少有三项，如果重写了相应的虚函数，那么虚表中的地址就会改变，指向自身的虚函数实现。如果派生类有自己的虚函数，那么虚表中就会添加该项。

3、  派生类的虚表中虚函数地址的排列顺序和基类的虚表中虚函数地址排列顺序相同。

3.   VC视频第三课this指针说明

我在论坛的VC教学视频版面发了帖子，是模拟MFC类库的例子写的，主要是说明在基类的构造函数中保存的this指针是指向子类的，我们在看一下这个例子：

#include <iostream.h>

class base;

base * pbase;

class base

{

public:

       base()

       {

              pbase=this;

       }

       virtual void fn()

       {

              cout<<"base"<<endl;

       }

};

class derived:public base

{

       void fn()

       {

              cout<<"derived"<<endl;

       }

};

derived aa;

void main()

{

       pbase->fn();

我在base类的构造函数中将this指针保存到pbase全局变量中。在定义全局对象aa，即调用derived aa;时，要调用基类的构造函数，先构造基类的部分，然后是子类的部分，由这两部分拼接出完整的对象aa。这个this指针指向的当然也就是aa对象，那么我们main()函数中利用pbase调用fn()，因为pbase实际指向的是aa对象，而aa对象内部的虚表指针指向的是自身的虚表，最终调用的当然是derived类中的fn()函数。

在这个例子中，由于我的疏忽，在derived类中声明fn()函数时，忘了加public关键字，导致声明为了private（默认为private），但通过前面我们所讲述的虚函数调用机制，我们也就明白了这个地方并不影响它输出正确的结果。不知道这算不算C++的一个Bug，因为虚函数的调用是在运行时确定调用哪一个函数，所以编译器在编译时，并不知道pbase指向的是aa对象，所以导致这个奇怪现象的发生。如果你直接用aa对象去调用，由于对象类型是确定的（注意aa是对象变量，不是指针变量），编译器往往会采用早期绑定，在编译时确定调用的函数，于是就会发现fn()是私有的，不能直接调用。：）

许多学员在写这个例子时，直接在基类的构造函数中调用虚函数，前面已经说了，在调用基类的构造函数时，编译器只“看到了”父类，并不知道后面是否后还有继承者，它只是初始化父类的虚表指针，让该虚表指针指向父类的虚表，所以你看到结果当然不正确。只有在子类的构造函数调用完毕后，整个虚表才构建完毕，此时才能真正应用C++的多态性。换句话说，我们不要在构造函数中去调用虚函数，当然如果你只是想调用本类的函数，也无所谓。

4.   参考资料：

1、文章《在VC6.0中虚函数的实现方法》，作者：backer ，网址：

http://www.mybole.com.cn/bbs/dispbbs.asp?boardid=4&id=1012&star=1

2、书《C++编程思想》 机械工业出版社

5.   后记

本想再写详细些，发现时间不够，总是有很多事情，在加上水平也有限，想想还是以后再说吧。不过我相信，这些内容也能够帮助大家很好的理解了。也欢迎网友能够继续补充，大家可以鼓动鼓动backer，让他从汇编的角度再给一个说明，哈哈，别说我说的。