C/C++内存管理

目录

一，C/C++内存分布

二，C++动态开辟空间

1，new/delete操作内置类型

2，new和delete操作自定义类型

3，new/delete底层实现

4，new和delete的实现原理

5，malloc/free和new/delete的区别

三，动态空间的析构和构造

---

一，C/C++内存分布

内存区域的大概介绍：

        C/C++中，我们目前需要了解的内存区域是栈区、堆区、静态区、常量区。其中，栈区用于临时存储数据，如函数的栈帧，局部变量等。堆区一般用来存储动态开辟的空间，如malloc、calloc、realloc、new等开辟的空间。静态区原名是代码段，一般存储全局变量和静态数据，在整个程序都可以使用。常量区用来存储常量，如字面量等。这些东西之前有过说明，这里我们简单提一下即可。

        以上东西全为基础，接下来我们来看看以下代码中的数据的存储空间。

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";     const 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在   C      staticGlobalVar在  C staticVar在    C       localVar在    A num1 在     A

char2在      A          * char2在    A pChar3在   A         * pChar3在   D ptr1在   A               * ptr1在   B

分析：前5个好理解，要注意的是后面六个选项。char2在函数栈帧中创建了一个数组，其代表了首元素的地址，存储在栈区中，而*char2代表首元素，也存储在栈区中。pChar3要注意的是，这里的const修饰的是*pChar3，即 "abcd" 是一个字面量，存储在常量区中，而pChar3是一个指针，存储在栈区中。ptr1的类型是int* ，指向堆区中开辟动态空间的首地址，因此，ptr1存储在栈区中，*ptr1指向数据，存储在堆区中。

---

二，C++动态开辟空间 1，new/delete操作内置类型

        我们都知道，C语言中有malloc、calloc、realloc、free语法进行动态空间的管理，而C++中通过new和delete操作符进行动态空间管理。其中new用来开辟空间，delete用来释放空间。其中，new可以对创建的空间进行初始化。

//动态开辟一个int型的空间 int* p1 = new int;//里面是随机值，不会初始化 int* p2 = new int(1);//动态开辟一个空间并初始化为1

//动态开辟多个int型的空间 int* p3 = new int[5]{ 1, 2 };//动态开辟5个空间并初始化为1 2 0 0 0  int* p4 = new int[10];//里面是随机值，不会初始化

//删除开辟一个空间delete p1; delete p2;

//删除开辟多个空间delete[] p3; delete[] p4;

        注意：C++中delete在释放中不支持一次多次释放，如下：

//下面是错误的用法

delete p1,p2;

delete[] p3,p4;

        new操作符在没有指定初始化的时候系统不会自动初始化。

#include <iostream> #include <string> using namespace std; int main() {     int n = 2;     int* a = new int[n];     a[0] = 0;     a[1] = 1;     a = new int[2 * n];//重新分配空间大小，里面全部是随机值     return 0; }

2，new和delete操作自定义类型

        这里要说明的是，操作自定义时，new/delete 和 malloc/free的最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数进行空间的初始化和释放。

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

    ~A()     {         cout << "~A():" << this << endl;     }

private:     int _a; };

int main() {     //通过调试可见，动态开辟空间初始化过程中调用了构造函数     //只调用一次构造函数     A* p1 = new A;     A* p2 = new A(1);     A aa1(1);     A aa2(1);     A aa3(1);     //调用了三次构造函数     A* p3 = new A[3]{ aa1, aa2, aa3 };     A* p4 = new A[3]{A(2), A(2), A(2) };     A* p5 = new A[3]{ 3, 3, 3 };

    //通过调试可见，动态空间释放过程中调用了析构函数     //只调用一次析构函数     delete p1;     delete p2;     //调用了三次析构函数     delete[] p3;     delete[] p4;     delete[] p5;     return 0; }

总的来说：

        new的本质：开空间+调用构造函数初始化。

        delete的本质：调用析构函数释放空间。

        通过以上可总结出，在开辟和释放的过程中，new关键字开辟了多少个动态类型空间，将会调用多少次构造函数；delete关键字释放了多少个动态类型空间，将会调用多少次析构函数。其中new开辟的空间无论是否进行初始化，构造函数都会被调用。

3，new/delete底层实现

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

operator new 和operator delete函数：

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

        operator delete: 该函数结构复杂，最终是通过free来释放空间。

底层函数的调用：

        当系统底层调用operator new和operator delete函数进行申请空间或释放空间时，无论开辟/释放一个空间或多个空间时，对应的函数只调用一次，即一次性直接分配或释放足够的内存空间。

        operator new和operator delete函数是通过C语言中的malloc和free来实现的，因此，两函数的调用方法也跟malloc/free一样。

Stack* p2 = (Stack*)operator new(sizeof(Stack)); //如同Stack* p2 = new Stack operator delete(p2); //如同delete p2

new的空间扩展：

        当使用new开辟多个内存空间时，其实还在这块空间的前面多开辟了四个字节的空间，用来存储开辟类型空间的数量，当delete内部实现到free时也会将其释放。

class Stack //一个栈类 { public:     Stack(int capacity = 4)     {         cout << "Stack(int capacity = 4)" << endl;

        _a = new int[capacity];         _top = 0;         _capacity = capacity;     }     ~Stack()     {         cout << "~Stack()" << endl;

        delete[] _a;         _a = nullptr;         _top = 0;         _capacity = 0;     } private:     int* _a;     int  _top;     int  _capacity; };

int main() {     Stack* p3 = new Stack[10];     int* p = (int*)p3 - 1;     cout << *p << endl; //输出10，记录了连续存储的10个Stack

    delete[] p3     return 0; }

        下面要说明的是，new/delete    new[]/delete[]    malloc/free一定要配对使用，否则结果将会是未定义，有时可能会出现系统崩溃，因此当系统释放空间时，可能会导致释放空间的位置不正确，具体如何释放取决于编译器的优化程度。这里我们了解即可。

4，new和delete的实现原理

内置类型：

        当申请内置类型的空间时，new和malloc，delete和free基本类似，不同的地方是： 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来释     放空间

5，malloc/free和new/delete的区别

共同点：

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

---

三，动态空间的析构和构造

        这里要说明的是：构造函数可以手动调用，但析构函数不可以手动调用。

class A { public:     A(int a = 0)         : _a(a)     {         cout << "A():" << this << endl;     }     ~A()     {         cout << "~A():" << this << endl;     } private:     int _a; }; int main() {     A* p1 = (A*)operator new(sizeof(A));

    A a(5);     //不能调用构造函数     //p1->A(1);

    //a->A(5);     //可以调用析构函数     p1->~A();     a.~A();     return 0; }