C/C++内存管理(malloc/calloc/realloc/free/new/delete/operator new/operator delete)

C语言中动态内存管理方式：malloc/calloc/realloc/free

C++内存管理方式:new/delete

operator new与operator delete函数

new和delete的实现原理

malloc/free和new/delete的区别 (用法上和底层)

内存泄漏

C/C++中程序内存区域划分：

1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。

2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。

3. 堆用于程序运行时动态内存分配，堆是可以上增长的。

4. 数据段--存储全局数据和静态数据，程序结束后由系统释放。

5. 代码段存放可执行的代码(函数体（类成员函数和全局函数）的二进制代码。)/只读常量。

C语言中动态内存管理方式：malloc/calloc/realloc/free

malloc（size是字节数）

void* malloc (size_t size);

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

如果开辟成功，则返回一个指向开辟好空间的指针。

如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

free

void free (void* ptr);

free函数用来释放动态开辟的内存。

如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

如果参数 ptr 是NULL指针，则函数什么事都不做。

calloc

C语言还提供了一个函数叫 calloc ， calloc 函数也用来动态内存分配。原型如下：

void* calloc (size_t num, size_t size);

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

realloc

realloc函数的出现让动态内存管理更加灵活。有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。

void* realloc (void* ptr, size_t size);

ptr 是要调整的内存地址
size 是调整之后新大小，返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
realloc在调整内存空间的是存在两种情况：1、原有空间之后有足够大的空间。这时候要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。（原地扩容）2、原有空间之后没有足够大的空间。原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。（异地扩容）

常见的动态内存错误

1.对NULL指针的解引用操作

void test() {

int *p = (int *)malloc(sizeof(int));

*p = 20;//如果p的值是NULL，就会有问题 free(p);

}

2.对动态开辟空间的越界访问

void test() {

        int i = 0;

        int *p = (int *)malloc(10*sizeof(int));

        if(NULL == p) {

        exit(EXIT_FAILURE);

        }

        for(i=0; i<=10; i++) {

        *(p+i) = i;//当i是10的时候越界访问

        }

        free(p);

}

3.对非动态开辟内存使用free释放

void test() {

int a = 10;

int *p = &a;

free(p);//p并不是动态开辟的内存

}

4 .使用free释放一块动态开辟内存的一部分

void test() {

int *p = (int *)malloc(100);

p++;

free(p);//p不再指向动态内存的起始位置

}

5. 对同一块动态内存多次释放

void test() {

int *p = (int *)malloc(100);

free(p);

free(p);//重复释放

}

6.动态开辟内存忘记释放（内存泄漏）

void test() {

        int *p = (int *)malloc(100);

        if(NULL != p) {

        *p = 20;

        }

}

int main() {

        test();

        while(1);

}

C++内存管理方式:new/delete

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

new/delete操作内置类型

void Test() {

// 动态申请一个int类型的空间

int* ptr1 = new int;

// 动态申请一个int类型的空间并初始化为10

int* ptr2 = new int(10);

// 动态申请10个int类型的空间

int* ptr3 = new int[3];

delete ptr1;

delete ptr2;

delete[] ptr3;

}

注意：申请和释放单个元素的空间，使用new和delete操作符；申请和释放连续的空间，使用 new[]和delete[]，一定要匹配起来使用。

new和delete操作自定义类型

new操作的功能是从堆上分配一块对象大小的空间，然后运行对象的初始化函数将这个空间地址返回；而delete则是与new相反的操作，它首先运行对象的析构函数，然后释放堆空间。

class A
{
public:
   A(int a = 0)
       : _a(a)
   {
       cout << "A():" << this << endl;

   }
   ~A()
   {
       cout << "~A():" << this << endl;
   }
private:
   int _a;
};
int main()
{
   //new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间,还会调用构造函数和析构函数
   A* p1 = (A*)malloc(sizeof(A));
   A* p2 = new A(1);
   free(p1);
   delete p2;
   // 内置类型是几乎是一样的
   int* p3 = (int*)malloc(sizeof(int));
   int* p4 = new int;
   free(p3);
   delete p4;
   A* p5 = (A*)malloc(sizeof(A) * 10);
   A* p6 = new A[10];
   free(p5);
   delete[] p6;
   return 0;
}

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

operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过 operator delete全局函数来释放空间。

class C {

};
int main()
{
   C* c = new C();
   delete c;
   return 0;
}

加入用VS2022编译这段代码并且反汇编，我们可以看到new/delete操作的实现：

可以看到，调用的实际上是一个叫做 operator new 和operator delete的函数，这也是C++中的操作符函数。

操作符都有对应的操作符函数。对于operator new函数来说，它的参数size是指须要申请的空间大小，一-般是指new对象的大小，而返回值是申请的堆地址。delete操作符函数的参数是对象的地址，它没有返回值。既然new/delete的实现是相应的操作符函数，那么，如果要实现new/delete,就只须要实现这两个函数就可以了。而这两个函数的主要功能是申请和释放堆空间，这再容易不过了，因为在C语言中已经实现了堆空间的申请和释放函数: malloc 和free。

实现源代码：

// new_ delete.CPP

extern "C" void* malloc (unsigned int) ;
extern "C" void free (void*) ;

void* operator new (unsigned int size)
{
   return malloc(size);
}

void operator delete (void* p)
{
   free(p);
}

void* operator new[](unsigned int size)
{
   return malloc(size);
}
void operator delete[](void* p)
{
   free(p);
}

在上面代码中除了newdelete 之外，我们还看到了new和delete它们分别是用来申请和释放对象数组的，在这里一并予以实现。另外除了申请和释放堆空间之外，没有看到任何对象构造和析构的调用，其实对象的构造和析构是在new/delete 之前/之后由编译器负责产生相应的代码进行调用的，new/delete仅仅负责堆空间的申请和释放，不负责构造和析构。

operator new 实际也是通过malloc来申请空间，如果 malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。operator new 实际也是通过malloc来申请空间，如果 malloc申请空间成功就直接返回，operator new 和operator delete就是对malloc和free的封装。

new和delete的实现原理

内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是： new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

自定义类型

new的原理

1. 调用operator new函数申请空间

2. 在申请的空间上执行构造函数，完成对象的构造

delete的原理

1. 在空间上执行析构函数，完成对象中资源的清理工作

2. 调用operator delete函数释放对象的空间

new T[N]的原理

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请

2. 在申请的空间上执行N次构造函数

delete[]的原理

1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

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在释放空间前会调用析构函数完成空间中资源的清理