C/C++内存管理

目录

C/C++内存分布

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

malloc、calloc、realloc和free

C++中动态内存管理方式

new和delete操作自定义类型

operator new和operator delete函数

new和delete的实现原理

内置类型

自定义类型

定位new和表达式(placement-new)

常见面试题

malloc/free和new/delete的区别？

内存泄漏

什么是内存泄漏，内存泄漏的危害？

如何一次在堆上申请4G的内存？

---

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);
}

以上代码中各个部分分别存储在内存中的哪一个区域？

【说明】
 1、栈又叫堆栈，用于存储非静态局部变量/函数参数/返回值等等，栈是向下增长的。
 2、内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。
 3、堆用于存储运行时动态内存分配，堆是向上增长的。
 4、数据段又叫静态区，用于存储全局数据和静态数据。
 5、代码段又叫常量区，用于存放可执行的代码和只读常量。

注：在一般情况下，在栈区开辟空间，先开辟的空间地址较高，而在堆区开辟空间，先开辟的空间地址较低。

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

malloc、calloc、realloc和free

1.malloc

maloc函数的功能是开辟指定字节大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL。传参时只需传入需要开辟的字节个数。

2.calloc

calloc函数的功能也是开辟指定大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL。calloc函数传参时需要传入开辟的内存用于存放的元素个数和每个元素的大小。calloc函数开辟好内存后会将空间内容中的每一个字节都初始化为0。

3.realloc

realloc函数可以用来调整已经开辟好的动态内存的大小，第一个参数是需要调整大小的动态内存的首地址，第二个参数是动态内存调整后的新大小。realloc函数如果开辟成功便返回开辟好的内存的首地址，开辟失败则返回NULL。（开辟成功存在本地扩和异地扩两种情况）

4.free

free函数的作用就是将malloc、calloc以及realloc函数申请的动态内存空间释放，其释放空间的大小取决于之前申请的内存空间的大小。

C++中动态内存管理方式

C语言内存管理的方式在C++中可以继续使用。但使用并不方便，且对自定义类型达不到要求，因此C++提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

1.动态申请单个某类型的空间

C++：

int* p = new int;

delete p;

C：

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

free(p);

2.动态申请多个某类型的空间

C++：

int* p = new int[5];//动态开辟5个int类型的空间

delete[] p;//销毁

C：

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

free(p);

3.动态申请单个某类型的空间并初始化

C++：

int* p = new int(1);//初始化为1

delete p;

C：

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

 *p=1;

 free(p);

4.动态申请多个某类型的空间并初始化

C++:

int* p = new int[3]{ 1,2,3 };

delete[]p6;

C:

int* p1= (int*)malloc(sizeof(int) * 3);

for(int i=1;i<=3;i++)//初始化

{

    *p=i;

}

free(p);

注意：c++是用操作符new,delete来进行动态内存管理，c是通过函数来管理动态内存，两者达成的效果是一致的。申请和释放单个元素的空间，使用new和delete操作符；申请和释放连续的空间，使用new[ ]和delete[ ]。

new和delete操作自定义类型

自定义类型pride:

class pride
{
public:
    pride(int a = 1)
        :_a(a)
    {
        cout << "pride()" << endl;
    }

    ~pride()
    {
        cout << "~pride()" << endl;
    }
private:
    int _a;
};

1.动态申请单个类的空间

pride* p = new pride;

pride* p1 = (pride*)malloc(sizeof(pride));
delete p;
free(p1);

2.动态申请多个类的空间

pride* p = new pride[5];
delete[] p;
pride* p1 = (pride*)malloc(sizeof(pride) * 5);
free(p1);

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

总结一下：
 1、C++中如果是申请内置类型的对象或是数组，用new/delete和malloc/free没有什么区别。
 2、如果是自定义类型，区别很大，new是开空间+构造函数，delete是析构函数+释放空间，而malloc和free仅仅是开空间和释放空间。
 3、建议在C++无论哪种类型都使用new和delete。

operator new和operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是系统提供的全局函数，new和delete在底层是通过调用全局函数operator new和operator delete来申请和释放空间的。
operator new和operator delete的用法和malloc和free的用法完全一样，其功能都是在堆上申请和释放空间。

int* p = (int*)operator new(sizeof(int));
int* p1 = (int*)malloc(sizeof(int));
operator delete(p);
free(p1);

实际上，operator new的底层是通过调用malloc函数来申请空间的，当malloc申请空间成功时直接返回；若申请空间失败，则尝试执行空间不足的应对措施，如果该应对措施用户设置了，则继续申请，否则抛异常。而operator delete的底层是通过调用free函数来释放空间的。

 

注意：虽然说operator new和operator delete是系统提供的全局函数，但是我们也可以针对某个类，重载其专属的operator new和operator delete函数，进而提高效率。 

new和delete的实现原理

内置类型

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

自定义类型

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函数完成N个对象空间的释放。

定位new和表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

使用格式：

new(place_address)type 或者 new(place_address)type(initializer-list)

其中place_address必须是一个指针，initializer-list是类型的初始化列表。

使用场景：

定位new表达式在实际中一般是配合内存池使用，因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，就需要使用定位new表达式进行显示调用构造函数进行初始化。

class pride
{
public:
    pride(int a = 1)
        :_a(a)
    {}

    ~pride()
    {}
private:
    int _a;
};

int main()
{
    //new(place_address)type 形式
    pride* p = (pride*)malloc(sizeof(pride));
    new(p)pride;

    //new(place_address)type(initializer-list) 形式
    pride* p1 = (pride*)malloc(sizeof(pride));
    new(p1)pride(20);

    

    //显示调用析构函数

    p->~pride();
    p1->~pride();
}

在使用定位new表达式进行显示调用构造函数进行初始化之后，malloc申请的空间才能算是一个对象

常见面试题

malloc/free和new/delete的区别？

相同：

都是从堆中申请的内存空间，需要手动释放。

不同点：

1.malloc和free是函数，new和delete是操作符

2.malloc申请的空间不初始化，new申请的空间会调用构造函数初始化

3.malloc申请空间时，需要传递空间大小，new只需在其后跟上空间的类型即可。

4.malloc返回值是void*，需要强转成我们需要的类型，而new直接是所需类型

5.malloc需要判空，因为申请失败时，返回的是NULL，new不需要，但new需要捕获异常。

6.对于申请自定义类型对象时，malloc/free只会开辟空间，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。

内存泄漏

什么是内存泄漏，内存泄漏的危害？

内存泄漏：

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

内存泄漏的危害：

长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

如何一次在堆上申请4G的内存？

#include

using namespace std;

int main()
{
    //0xffffffff转换为十进制就是4G
    void* p = malloc(0xffffffff);
    cout << p << endl;
    return 0;
}

需要在64位平台下，因为在32位的平台下，内存大小为4G，但是堆只占了其中的2G左右