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

没有对象怎么办？学了面向对象语言之后，很简单，给自己new一个！

在C++和Java中，可以向内存申请对象。new一个就好了。

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

new/delete操作内置类型

void Test() {  

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

 int* ptr1 = new int;  //new一个对象

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

int* ptr2 = new int(10);  

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

int* ptr3 = new int[10]; 

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

内存泄漏

什么是内存泄漏？

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。（在堆上动态申请的内存，不使用了，又没有主动释放，就存在内存泄漏。）

内存泄漏是缓慢、隐性的杀手，当我们不小心忘记释放已分配块，而在堆里创建了垃圾时，会发生这种问题。

例如，下面的函数分配了一个堆块x，然后不释放它就返回：

void leak(int n)
{
    int* x = (int*)malloc(n * sizeof(int));
    return;  //x is garbage at this point
}

内存泄漏的危害：

如果出现内存泄漏的进程正常结束，进程结束时这些内存会还给系统，不会有什么大伤害。

但是出现内存泄漏的进程非正常结束，会导致系统会越来越慢，卡死宕机。比如僵尸进程。

如果经常调用leak,那么渐渐的，堆里就会充满了垃圾，最糟糕的情况下，会占用整个虚拟地址空间。对于像守护进程和服务器这样需要长期运行的程序来说，内存泄漏是特别严重的，根据定义这些程序是不会终止的，系统会越来越慢，甚至卡死宕机。