C/C++内存管理方式 干货好文助你深度理解

写在前面：

本文旨在向大家完整综合的进行C语言和C++的内存管理方式，涉及到的内容也会比较全面。在自己梳理回顾的过程中也想与大家一起分享。如有 不足之处，欢迎大家指正。

1.c/c++内存分布
2.C语言中动态内存管理方式：malloc/calloc/realloc和free
3.c++内存管理方式：new和delete
4.malloc/free和new/delete的区别

ps：本文主要探究“内存管理方式”。具体的相关实现原理会在别的文章中再具体给出，读者可以自行查询。

1.C/C++内存分布：

开门见山，我们看一下下面这段代码:

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
 static int staticVar = 1;
 int localVar = 1;
 
 int num1[10] = {1, 2, 3, 4};
 char char2[] = "abcd";
 char* pChar3 = "abcd";
 int* ptr1 = (int*)malloc(sizeof (int)*4);
 int* ptr2 = (int*)calloc(4, sizeof(int));
 int* ptr3 = (int*)realloc(ptr2, sizeof(int)*4);
 free (ptr1);
 free (ptr3);
}
//试着分析一下代码回答下列问题？

选择题：
A.栈 B.堆 C.数据段 D.代码段

globalVar在哪里？____ staticGlobalVar在哪里？____
staticVar在哪里？____ localVar在哪里？____
num1 在哪里？____

char2在哪里？____ *char2在哪里？___
pChar3在哪里？____ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____

想要答对其中一些问题其实不难，难的却是全部答对。OK，我们往下进行：

【说明】

1. 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共
   享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段–存储全局数据和静态数据。//多数地方叫作全局数据区或者静态区。后边统一也这么称呼。
5. 代码段–可执行的代码/只读常量。
   //细分的话，可以分为字符常量区 ：常量字符串放与此，程序结束时由系统释放AND 程序代码区：存放函数体的二进制代码

敲黑板了！！同学们！！

     大家在参考别的文章的时候可能都会发现不同的内存管理的总结，可能就会有点懵逼。 比如，你可能在别的地方会看到“静态区（或者叫全局数据区）”的概念。
      其实是这样的（个人理解，可以指正）：全局变量和静态变量存储在一块。
       
在C语言中
静态区又分为了BSS区和数据段。
BSS段：未初始化的全局变量和静态变量；
数据段：已初始化的全局变量和静态变量；

在C++中
对于是否初始化没有明确的划分。即：不管有没有初始化，大家都是放在一块区域的，那这块区域我们叫做："全局区(或静态区)"
所以最开始那道程序的答案是： CCCAAAAADAB (疑惑点可以评论区提出)

2.C语言中动态内存管理方式

malloc/calloc/realloc和free
有同学可能会有疑问：我记得不是还有一个alloc吗？因为alloc是在栈上申请空间的啊。
在程序的执行期间分配内存时，内存区域中的这个空间称为堆（heap）。还有另一个内存区域，称为堆栈（stack），其中的空间分配给函数的参数和本地变量。在执行完函数后，存储参数和本地变量的内存空间就会释放。堆中的内存是由程序员控制的。

1.malloc()：

  int *pNumber = (int*)malloc(100);          　　　　 // 分配100字节内存
  int *pNumber = (int*)malloc(25*sizeof(int));        //存储25个int值得内存

类型转换（int*）将函数返回的地址转换成 int 类型的指针。malloc()返回 void 类型的指针，void* 可以指向任何类型的数据，不能取消对 void 指针的引用，因为它指向未具体说明的对象。如果因某种原因而不能分配请求的内存，malloc()会返回一个 NULL 指针。

用 if 语句检查是否分配：

    int *pNumber = (int*)malloc(25*sizeof(int));

    if (!pNumber)
    {
        // 内存分配失败的处理代码
    }    
释放动态分配的内存：

    free(pNumber);

    pNumber = NULL;

2.colloc() ：
　与 malloc() 相比有两个优点：
　（1）它把内存分配为给定大小的数组；
　（2）它初始化了所分配的内存，所有位都是 0。

int *pNumber = (int*)calloc(75, sizeof(int));    
    // 分配了包含75个int元素的数组
　　如果不能分配所请求的内存，返回值就是 NULL。

可以让编译器执行类型转换：

    int *pNumber = calloc(75, sizeof(int));

3.扩展动态分配的内存 realloc() :

realloc() 函数可以重用或扩展以前用 malloc()或 calloc()（或者realloc()）分配的内存。
realloc()的两个参数：
（1）一个是包含地址的指针，该地址以前由malloc()、colloc()或realloc()返回。
（2）要分配的新内存的字节数。

realloc()函数分配第二个参数指定的内存量，把第一个指针参数引用的、以前分配的内存内容传递到新分配的内存中，传递的内容量是新旧内存中区域较小的那一个。函数返回一个指向新内存的void*指针，如果分配失败，返回NULL。如果第一个参数是NULL，就分配第二个参数指定的新内存，类似malloc()。
如果将分配的内存减少，realloc仅仅是改变索引的信息。

如果是将分配的内存扩大，则有以下情况：
1）如果当前内存段后面有需要的内存空间，则直接扩展这段内存空间，realloc()将返回原指针。
2）如果当前内存段后面的空闲字节不够，那么就使用堆中的第一个能够满足这一要求的内存块，将目前的数据复制到新的位置，并将原来的数据块释放掉，返回新的内存块位置。
3）如果申请失败，将返回NULL，此时，原来的指针仍然有效。

**注意**：如果调用成功，不管当前内存段后面的空闲空间是否满足要求，都会释放掉原来的指针，重新返回一个指针，虽然返回的指针有可能和原来的指针一样，即不能再次释放掉原来的指针。

动态分配内存的基本原则 :

* 避免分配大量的小内存块。分配堆上的内存有一些系统开销，所以分配许多小的内存块
　　比分配几个大内存块的系统开销大。

* 仅在需要时分配内存。只要使用完堆上的内存块，就释放它。

* 总是确保释放以分配的内存。在编写分配内存的代码时，就要确定在代码的什么地方
　　释放内存。

* 在释放内存之前，确保不会无意中覆盖堆上已分配的内存地址，否则程序就会出现内存
　　泄漏。在循环中分配内存时，要特别小心。

void Test ()
{
 int* p1 = (int*) malloc(sizeof(int));
 free(p1);
 
 // 1.malloc/calloc/realloc的区别是什么？
 int* p2 = (int*)calloc(4, sizeof (int));
 int* p3 = (int*)realloc(p2, sizeof(int)*10);
 
 // 这里需要free(p2)吗？
 free(p3 );
}

3.C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
3.1 new/delete操作内置类型

void Test ()
{
int* p1 = (int*) malloc(sizeof(int));
free(p1);

// 1.malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);

// 这里需要free(p2)吗？
free(p3 );
}
void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;

// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);

// 动态申请10个int类型的空间
int* ptr6 = new int[3];

delete ptr4;
delete ptr5;
delete[] ptr6;
}

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]

3.2 new和delete操作自定义类型

class Test
{
public:
 Test()
 : _data(0)
 {
 cout<<"Test():"<<this<<endl;
 }
 ~Test()
 {
 cout<<"~Test():"<<this<<endl;
 }
 
private:
 int _data;
};
void Test2()
{
 // 申请单个Test类型的空间
 Test* p1 = (Test*)malloc(sizeof(Test));
 free(p1);
 
 // 申请10个Test类型的空间
 Test* p2 = (Test*)malloc(sizoef(Test) * 10);
 free(p2);
}

void Test2()
{
 // 申请单个Test类型的对象
 Test* p1 = new Test;
 delete p1;
 
 // 申请10个Test类型的对象
 Test* p2 = new Test[10];
 delete[] p2;
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

4. malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。
不同的地方是：

1. malloc和free是函数，new和delete是操作符
2. malloc申请的空间不会初始化，new可以初始化
3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间
   后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
7. new/delete比malloc和free的效率稍微低点，因为new/delete的底层封装了malloc/free

ps:new和delete的实现原理会在别篇文章中给出。