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
#include
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;
}