C++内存管理

                                                                                                                    内存管理

一、内存管理
 1)内存分类
   在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
   1.1：栈，在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释
        放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
   1.2：堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要
     对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
   1.3：自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命
     的。
   1.4：全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化
     的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
   1.5：常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。
 2)明确区分堆与栈
   2.1：实例
  void f() { int* p=new int[5]; }  //delete []p
   　这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？
     他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在程序会
  先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中。
   2.2：堆和栈区别
  1、管理方式不同：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，分配、释放工作由
       程序员控制，容易产生memory leak。
 　　2、空间大小不同：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什
       么限制的。但是对于栈来讲，一般都是有一定的空间大小的。
       (我们可以修改：打开工程，依次操作菜单如下：Project->Setting->Link，在Category
        中选中Output，然后在Reserve中设定堆栈的最大值和commit。注意：reserve最小值为
        4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可
        能增加内存的开销和启动时间。)
 　　3、能否产生碎片不同：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，
       使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列。
 　　4、生长方向不同：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生
       长方向是向下的，是向着内存地址减小的方向增长。
 　　5、分配方式不同：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态
       分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的
       动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
 　　6、分配效率不同：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放
       栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函
       数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法
       （具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如
       果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序
       数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率
       比栈要低得多。
  **无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，
    要么是摧毁程序的堆、栈结构，产生以想不到的结果。
 3)内存分配
        当你必须要使用new 和delete时，你不得不控制C++中的内存分配。你需要用一个全局的new 和delete来
     代替系统的内存分配符，并且一个类一个类的重载new 和delete。
     一个防止堆破碎的通用方法是从不同固定大小的内存持中分配不同类型的对象。对每个类重载new 和
     delete就提供了这样的控制。
  3.1：重载全局的new和delete操作符
   void *operator new(size_t size)
   {
    void *p = malloc(size);
    return (p);
   }
   void operator delete(void *p);
   {
    free(p);
   }
  3.2：也可以对单个类的new 和 delete 操作符重载。这是你能灵活的控制对象的内存分配。
   class TestClass {
   public:
    void * operator new(size_t size);
    void operator delete(void *p);
    // .. other members here ...
   };
   void *TestClass::operator new(size_t size)
   {
    void *p = malloc(size); // Replace this with alternative allocator
    return (p);
   }
   void TestClass::operator delete(void *p)
   {
    free(p); // Replace this with alternative de-allocator
   }
  通过重载new 和 delete 操作符的方法，你可以自由地采用不同的分配策略，从不同的内存池中分配不同的
  类对象。
  3.3：为单个的类重载 new[ ]和delete[ ]
   class TestClass {
   public:
    void * operator new[ ](size_t size);
    void operator delete[ ](void *p);
    // .. other members here ..
   };
   void *TestClass::operator new[ ](size_t size)
   {
    void *p = malloc(size);
    return (p);
   }
   void TestClass::operator delete[ ](void *p)
   {
    free(p);
   }
   int main(void)
   {
    TestClass *p = new TestClass[10];
    // ... etc ...
    delete[ ] p;
   }
 4)常见的内存错误及其对策
  4.1：*内存分配未成功，却使用了它
   常用解决办法是，在使用内存之前检查指针是否为NULL。如果指针p是函数的参数，那么在函数的入口
   处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存，应该用if(p==NULL) 或if(p!=NULL)
   进行防错处理。
   (assert的作用是计算表达式 expression ，如果其值为假（即为0），那么它先向stderr打印一条出
   错信息，然后通过调用 abort 来终止程序运行。)
  4.2：*内存分配虽然成功，但是尚未初始化就引用它(野指针)
   内存的缺省初值究竟是什么并没有统一的标准，。所以无论用何种方式创建数组，都别忘了赋初值，即
   便是赋零值也不可省略，不要嫌麻烦。
  4.3：*内存分配成功并且已经初始化，但操作越过了内存的边界。
  4.4：*忘记了释放内存，造成内存泄露。
   含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有
   一次程序突然死掉，系统出现提示：内存耗尽。
   动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误
   （new/delete同理）。
  4.5：*释放了内存却继续使用它。
   有三种情况：
    1、程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应
       该重新设计数据结构，从根本上解决对象管理的混乱局面。
    2、函数的return语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，因为该内存在函
       数体结束时被自动销毁。
    3、使用free或delete释放了内存后，没有将指针设置为NULL。导致产生“野指针”。
  
  4.6：策略
   　【规则1】用malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用
        指针值为NULL的内存。
   　【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。
   　【规则3】避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作。
   　【规则4】动态内存的申请与释放必须配对，防止内存泄漏。
   　【规则5】用free或delete释放了内存之后，立即将指针设置为NULL，防止产生“野指针”。
  
 6)指针与数组的对比
  数组：要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而不是指向）一块
     内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。
  指针：可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。指针远比
     数组灵活，但也更危险。
  6.1：修改内容
  6.2：内容复制
  6.3：计算内存容量
   用运算符sizeof可以计算出数组的容量（字节数）。但是sizeof(指针)的值却是4。这是因为sizeof(p)
   得到的是一个指针变量的字节数，相当于sizeof(char*)，而不是p所指的内存容量。C++/C语言没有办法
   知道指针所指的内存容量，除非在申请内存时记住它。
  6.4：注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。如下示例中，
   不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)。
   void Func(char a[100])
   {
   　cout<< sizeof(a) << endl; // 4字节而不是100字节
   }
  6.5：指针参数是如何传递内存的？
   如果函数的参数是一个指针，不要指望用该指针去申请动态内存。如下示例中，Test函
   数的语句GetMemory(str, 200)并没有使str获得期望的内存，str依旧是NULL，为什么？
   void GetMemory(char *p, int num)
   {
   　p = (char *)malloc(sizeof(char) * num);
   }
   void Test(void)
   {
   　char *str = NULL;
   　GetMemory(str, 100); // str 仍然为 NULL
   　strcpy(str, "hello"); // 运行错误
   }
   毛病出在函数GetMemory中。编译器总是要为函数的每个参数制作临时副本，指针参
   数p的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p的内容，就导致参数p
   的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p申请了新的内存，
   只是把_p所指的内存地址改变了，但是p丝毫未变。所以函数GetMemory并不能输出任何
   东西。事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。
   如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”，见示例：
   void GetMemory2(char **p, int num)
   {
   　*p = (char *)malloc(sizeof(char) * num);
   }
   void Test2(void)
   {
   　char *str = NULL;
   　GetMemory2(&str, 100); // 注意参数是 &str，而不是str
   　strcpy(str, "hello");
   　cout<< str << endl;
   　free(str);
   }
   由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值来传递动态内
   存。这种方法更加简单，见示例：
   char *GetMemory3(int num)
   {
   　char *p = (char *)malloc(sizeof(char) * num);
   　return p;
   }
   void Test3(void)
   {
   　char *str = NULL;
   　str = GetMemory3(100);
   　strcpy(str, "hello");
   　cout<< str << endl;
   　free(str);
   }
   用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了。
   这里强调不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消
   亡。
  6.6：杜绝“野指针”
   “野指针”不是NULL指针，是指向“垃圾”内存的指针
   1、指针变量没有被初始化。
     ，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。
   2、指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。
   3、指针操作超越了变量的作用域范围。
 7)malloc/free与new/delete对比
  malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。
  7.1：对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动
       执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在
    编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。
  7.2：我们不要企图用malloc/free来完成动态对象的内存管理，应该用new/delete。由于内部数据类型的“对
       象”没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。既然new/delete的功能完
    全覆盖了malloc/free，为什么C++不把malloc/free淘汰出局呢？这是因为C++程序经常要调用C函数，
    而C程序只能用malloc/free管理动态内存。 
 8)内存耗尽怎么办？
  如果在申请动态内存时找不到足够大的内存块，malloc和new将返回NULL指针，宣告内存申请失败。
  通常有三种方式处理“内存耗尽”问题。
  8.1：判断指针是否为NULL，如果是则马上用return语句终止本函数。
     8.2：判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。
     8.3：为new和malloc设置异常处理函数。例如Visual C++可以用_set_new_hander函数为new设置用户自己定义
   的异常处理函数，也可以让malloc享用与new相同的异常处理函数。
 9)malloc/free的使用要点
  9.1：函数malloc的原型如下:
    void * malloc(size_t size);
    * malloc返回值的类型是void *，所以在调用malloc时要显式地进行类型转换，将void* 转换成所需
    要的指针类型。
  9.2：函数free的原型如下：
    void free( void * memblock );
 10)new/delete的使用要点
  10.1：new内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，new在创建动态
     对象的同时完成了初始化工作。如果对象有多个构造函数，那么new的语句也可以有多种形式。
     如果用new创建对象数组，那么只能使用对象的无参数构造函数。
  10.2：在用delete释放对象数组时，留意不要丢了符号‘[]’  
  
二、C++中的健壮指针和资源管理  
 1)
  1.1：第一条规则（RAII）
     在构造函数中分配资源，在析构函数中释放资源。
   auto_ptr
  1.2：Resource Transfer
  
三、内存泄漏  
 1)C++中动态内存分配引发问题的解决方案
 2)C/C++内存泄漏及其检测工具
  Smart Pointer，Garbage Collection等
  2.1：内存泄漏的定义
   一般我们常说的内存泄漏是指堆内存的泄漏。应用程序一般使用malloc，realloc，new等函数从堆中分
   配到一块内存，使用完后，程序必须负责相应的调用free或delete释放该内存块，否则，这块内存就不
   能被再次使用，我们就说这块内存泄漏了。
  2.2：内存泄漏的发生方式
   2.2.1：常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存
       泄漏。
   2.2.2：偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。
   2.2.3：一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有
       一块仅且一块内存发生泄漏
   2.2.4：隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。
  2.3：检测内存泄漏
   检测内存泄漏的关键是要能截获住对分配内存和释放内存的函数的调用。如果要检测堆内存的泄漏，那
   么需要截获住malloc/realloc/free和new/delete就可以了。
  2.4：在Windows平台下，检测内存泄漏的工具常用的一般有三种
   MS C-Runtime Library内建的检测功能；
   外挂式的检测工具，诸如，Purify，BoundsChecker 等；
   利用WindowsNT自带的Performance Monitor。
   这三种工具各有优缺点，MS C-Runtime Library虽然功能上较之外挂式的工具要弱，但是它是免费的；
   Performance Monitor虽然无法标示出发生问题的代码，但是它能检测出隐式的内存泄漏的存在，这是
   其他两类工具无能为力的地方。

四、探讨C++内存回收
 1)基本概念
  1.1：栈，一般用于存放局部变量或对象，几乎所有的临时对象都是栈对象。
   编译器会为我们生成了临时对象，而生成这些临时对象的时间和空间的开销可能是很大的，所以，
   你也许明白了，为什么对于“大”对象最好用const引用传递代替按值进行函数参数传递了。
  2.2：堆，又叫自由存储区，它是在程序执行的过程中动态分配的，所以它最大的特性就是动态性。
  2.3：静态存储区，所有的静态对象、全局对象都于静态存储区分配。
   (1)局部静态对象的生命期是从其所在函数第一次被调用，更确切地说，是当第一次执行到该静态对象的声
   明代码时，产生该静态局部对象，直到整个程序结束时，才销毁该对象。
   (2)class的静态成员对象随着第一个classobject的产生而产生，在整个程序结束时消亡。
 2)三种内存对象的比较
  2.1：禁止产生堆对象
   就是重载new operator为private，为了对称，最好将operator delete也重载为private。
  2.1：禁止产生栈对象
   
五、浅议C++ 中的垃圾回收方法
 1)