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等开辟的空间。静态区原名是代码段,一般存储全局变量和静态数据,在整个程序都可以使用。常量区用来存储常量,如字面量等。这些东西之前有过说明,这里我们简单提一下即可。

C/C++内存管理_第1张图片

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

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在         localVar在    A
num1 在     A


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

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

C/C++内存管理_第2张图片


二,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;
}

C/C++内存管理_第3张图片

        下面要说明的是,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;
}

你可能感兴趣的:(c++,开发语言)