C/C++中的动态内存管理

动态内存管理

堆

• 内存格局通常分成四个区
  
  • 全局数据区（data area）
    
    • 全局变量
    • 静态数据
    • 常量存放
  • 代码区（code area）
    
    • 所有类成员函数代码
    • 所有非成员函数代码
  • 栈区（stack area）
    
    • 为运行函数而分配的局部变量
    • 函数参数
    • 返回数据
    • 返回地址等
  • 堆区（自由存储区）（heap area）
• 为什么要使用new和delete？
  
  • malloc函数在分配空间的时候不能调用构造函数。
  • 而类对象的建立是分配空间、构造结构以及初始化的三位一体，它们统一由构造函数来完成。
  • 从程序设计的需要来看，在分配内存申请的时候，总是知道分配的空间派什么用，而且分配空间大小总是某个数据类型的整数倍。
  • 因而，C++用new代替C的malloc（）是必然的。

C/C++内存管理对比

C语言

• 动态内存分配函数
  
  • malloc
  • alloc
  • realloc
  • free
• realloc,malloc,calloc的区别
  三个函数的申明分别是:

void* realloc(void* ptr, unsigned newsize);   void* malloc(unsigned size);   void* calloc(size_t numElements, size_t sizeOfElement);   

都在stdlib.h函数库内。
它们的返回值都是请求系统分配的地址，如果请求失败就返回NULL 。

• malloc用于申请一段新的地址，参数size为需要内存空间的长度，如：

char* p;   p=(char*)malloc(20);  

calloc与malloc相似，参数sizeOfElement为申请地址的单位元素长度，numElements为元素个数，如：

char* p;   p=(char*)calloc(20,sizeof(char));   

realloc是给一个已经分配了地址的指针重新分配空间，参数ptr为原有的空间地址，newsize是重新申请的地址长度 。

char* p;   p=(char*)alloc(sizeof(char)*20);   p=(char*)realloc(p,sizeof(char)*40);  

注意，这里的空间长度都是以字节为单位。

• 区别:
  
  • 函数malloc不能初始化所分配的内存空间，而函数calloc能。如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0；反之， 如果这部分内存曾经被分配过，则其中可能遗留有各种各样的数据。也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行。但经过一段时间(内存空间还已经被重新分配)可能会出现问题。
  • 函数calloc() 会将所分配的内存空间中的每一位都初始化为零。也就是说，如果你是为字符类型或整数类型的元素分配内存，那么这些元素将保证会被初始化为0；如果你是为指针类型的元素分配内存，那么这些元素通常会被初始化为空指针；如果你为实型数据分配内存，则这些元素会被初始化为浮点型的零。
  • 函数malloc向系统申请分配指定size个字节的内存空间。返回类型是 void*类型。void*表示未确定类型的指针。C、C++规定，void* 类型可以强制转换为任何其它类型的指针。
  • realloc可以对给定的指针所指的空间进行扩大或者缩小，无论是扩张或是缩小，原有内存的中内容将保持不变。当然，对于缩小，则被缩小的那一部分的内容会丢失。realloc并不保证调整后的内存空间和原来的内存空间保持同一内存地址。相反，realloc返回的指针很可能指向一个新的地址。
  • realloc是从堆上分配内存的.当扩大一块内存空间时，realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平；如果数据后面的字节不够，问题就出来了，那么就使用堆上第一个有足够大小的自由块，现存的数据然后就被拷贝至新的位置，而老块则放回到堆上。这句话传递的一个重要的信息就是数据可能被移动。
  • calloc在动态分配完内存后，自动初始化该内存空间为零，而malloc不初始化，里边数据是随机的垃圾数据。并且malloc申请的内存可以是不连续的，而calloc申请的内存空间必须是连续的。
  • 当程序运行过程中malloc了，但是没有free的话,会造成内存泄漏.一部分的内存没有被使用，但是由于没有free，因此系统认为这部分内存还在使用，造成不断的向系统申请内存,使得系统可用内存不断减少。但是内存泄漏仅仅指程序在运行时，程序退出时，OS将回收所有的资源。因此，适当的重启一下程序，有时候还是有点作用。

来源： http://blog.csdn.net/shuaishuai80/article/details/6140979

C++

• new / delete —— 动态内存管理对象
• new[] / delete[] —— 动态内存管理对象数组
• new是动态分配内存的运算符，自动计算需要分配的空间，在C++中，它属于重载运算符，可以对多种数据类型形式进行分配内存空间，比如int型、char型、结构体型和类等的动态申请的内存分配，分配类的内存空间时，同时调用类的构造函数，对内存空间进行初始化，即完成类的初始化工作。

• delete是撤销动态申请的内存运算符。delete与new通常配对使用，与new的功能相反，可以对多种数据类型形式的内存进行撤销，包括类，撤销类的内存空间时，它要调用其析构函数，完成相应的清理工作，收回相应的内存资源。

• 用法：

void Test (){    int* p4 = new int; // 动态分配 4 个字节（ 1 个 int）的空间单个数据    int* p5 = new int(3); // 动态分配 4 个字节（ 1 个 int）的空间并初始化为 3    int* p6 = new int[3]; // 动态分配 12 个字节（ 3 个 int）的空间    delete p4 ;    delete p5 ;    delete[] p6 ;}

new/delete与malloc/free之间的联系和区别

• malloc/free和new/delete的联系

  • 存储方式相同。malloc和new动态申请的内存都位于堆中。申请的内存都不能自动被操作系统收回，都需要配套的free和delete来释放。
  • 除了带有构造函数和析构函数的类等数据类型以外，对于一般数据类型，如int、char等等，两组动态申请的方式可以通用，作用效果一样，只是形式不一样。
  • 内存泄漏对于malloc或者new都可以检查出来的，区别在于new可以指明是那个文件的那一行，而malloc没有这些信息。
  • 两组都需要配对使用，malloc配free，new配delete，注意，这不仅仅是习惯问题，如果不配对使用，容易造成内存泄露。同时，在C++中，两组之间不能混着用，虽说有时能编译过，但容易存在较大的隐患。

• malloc/free和new/delete的区别

  • malloc和free返回void类型指针，new和delete直接带具体类型的指针。
  • malloc和free属于C语言中的函数，需要库的支持，而new/delete是C++中的运算符，况且可以重载，所以new/delete的执行效率高些。C++中为了兼用C语法，所以保留malloc和free的使用，但建议尽量使用new和delete。

  • 在C++中， new是类型安全的，而malloc不是。例如：

    int* p = new char[10];                    // 编译时指出错误  delete [ ]p;                                     //对数组需要加中括号“[ ]”  int* p = malloc(sizeof(char )*10);    // 编译时无法指出错误  free (p);                                       //只需要所释放内存的头指针  

  • 使用new动态申请类对象的内存空间时，类对象的构建要调用构造函数，相当于对内存空间进行了初始化。而malloc动态申请的类对象的内存空间时，不会初始化，也就是说申请的内存空间无法使用，因为类的初始化是由构造函数完成的。delete和free的意义分别于new和malloc相反。

  • 不能用malloc和free来完成类对象的动态创建和删除。

来源：http://blog.csdn.net/kingcat666/article/details/44781983

剖析new/delete和new[]/delete[]

http://blog.csdn.net/hazir/article/details/21413833
这篇博客和博客底下的留言把这个问题剖析的很清楚了，可以多看几遍~

利用宏实现NEW_ARRAY/DELETE_ARRAY，以模拟new[]/delete[]申请和释放数组的功能

#define NEW_ARRAY(P, TYPE, N)                       \do{                                                 \    int* P_NEW = (int*)malloc(sizeof(TYPE)*N + 4);  \    ((int*)P_NEW)[0] = N;                           \    P = (TYPE*)(P_NEW + 1);                         \    int I_NEW = 0;                                  \    for (; I_NEW < N; I_NEW++)                      \        new(P + I_NEW)TYPE;                         \} while (false);#define DELETE_ARRAY(P, TYPE)                       \do{                                                 \    int n = *((int*)P - 1);                         \    while (n--)                                     \        (P[n]).~TYPE();                             \    free((int*)P - 1);                              \} while (false);

1、申请时在数组对象的上面还多分配了 4 个字节用来保存数组的大小，但是最终返回的是对象数组的指针，而不是所有分配空间的起始地址。
2、do{}while(false) 是为了生成一个局部域，定义和使用临时变量，避免变量重定义。