C语言的动态内存管理你了解吗_C/C++

C/C++内存分配方式

在学习C语言阶段的时候，创建一个变量，编译器会为它分配一块内存。而创建一个C++对象的时候，编译器会为这个对象分配内存，并且调用合适的构造函数进行初始化。

那么编译器的内存分配方式是怎样的呢？

内存分配可以有以下的几种方式

从静态存储区分配。这样的分配方式在程序开始前就可以为对象/变量分配，这块空间在整个程序运行期间都存在。
从栈区分配。调用函数时，函数的参数，局部变量，返回地址等存储在堆栈上，函数执行结束时将会自动释放这些内存空间，栈区的内存空间远远小于堆区。
从堆区分配。这种内存分配方式被称为动态内存分配，堆区又被称为“自由存储单元”，运行时通过调用相应的函数来申请和释放内存。

有时候我们并不知道程序中的对象确切地需要多少内存空间，动态内存分配则很好地处理了这种需求。

C++内存管理方式

C库中提供了函数malloc，以及它的变种函数realloc、calloc来动态地申请内存空间。使用函数free来释放动态申请出的内存空间。

				?

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

使用malloc需要指定空间大小，并且要强制类型转化，因为它只是简单地分配了一块空间，返回的是void*,而C++中不允许将空类型的指针赋予给其他类型的指针。另外，如果你申请一块内存之后，没有对这个指针进行正确的初始化，有可能会导致程序运行失败，并且如果忘记释放动态申请的内存空间，则会造成内存泄露等危害……

在创建一个C++对象时，编译器会做这两件事：

1.为对象分配内存。

2.编译器自动调用构造函数初始化该内存。

构造函数不支持显式地调用，意味着如果使用malloc函数创建一个对象，那么这个对象将不能够调用构造函数，仅仅只是开辟了一块空间。但是我们必须要确保对象被初始化，因为未初始化对象是大部分程序出错的主要原因。总而言之，C中的动态内存管理无法满足C++中动态对象的需求。

所以提出了new和delete.关键字

new和delete的使用

				?

									int main(void)

									{

									    //基本内置类型

									    //开辟一个int类型的空间

									    int* ptr2 = new int;

									    //开辟多个int类型空间

									    int* ptr3 = new int[5];

									    //开辟一个int类型并初始化为1

									    int* ptr4 = new int(1);

									    delete ptr2;

									    delete[] ptr3;

									    delete ptr4;

									    return 0;

									}

new和delete的使用方式：

				?

									1.开辟一个空间: new 类型;       对应释放： delete 对象；2.开辟多个空间：new 类型[个数]   对应释放：delete[] 对象；3.开辟并初始化： new 类型(初始化数据) 对应释放：delete 对象  1.开辟一个空间: new 类型;       对应释放： delete 对象；

									2.开辟多个空间：new 类型[个数]   对应释放：delete[] 对象；

									3.开辟并初始化： new 类型(初始化数据) 对应释放：delete 对象

new和delete的骚操作

内置类型

对于内置类型，new和delete与C的内存管理函数做了差不多的事情，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

自定义类型

new表达式：

调用opreator new函数分配内存
调用构造函数初始化该内存

delete表达式:

调用析构函数清理对象中的资源
调用operator delete释放空间。

operator new( ) 和operator delete( )这两个内存分配函数是系统提供的全局函数,实际上是对malloc和free的各种行为进行了封装。

new和delete的区别

new、delete 和 malloc、free的区别有哪些呢？

new和delete是关键字，malloc和free是函数
malloc申请的空间不会初始化，new会初始化。
malloc需要手动计算空间大小并传递，new不需要
malloc的返回值是void*，使用时必须强制类型转换；new不需要，后面跟的是空间的类型。
malloc申请失败，返回NULL，所以调用后要判断是否开辟成功；new需要捕获异常
malloc只是开辟空间，不会调用构造函数，free释放空间不会调用析构函数；new在申请空间后会调用构造函数初始化对允许象，delete会调用析构函数清理对象中的资源，然后再释放空间。

重载new和delete

C++允许重载new和delete，以实现我们自己的存储分配方案。但是注意重载operator new和operator delete时，仅仅只能改变原本的内存分配方式。同重载其他的运算符一样，可以分为重载成全局和针对特定类的内存分配函数。

重载全局

重载一个全局的new和delete会导致默认版本完全不能被访问。

重载operator new的要求：

必须有一个size_t参数，该参数将接收要开辟空间的长度。
返回一个指向对象的指针，该对象的长度等于或者大于所申请的长度。
如果分配失败，不仅仅要返回一个0，还需产生一个异常信息之类的现象，明确分配内存时出了问题。
返回值是一个void*

重载operator delete的要求

参数是一个指向由operator new()分配的void*类型的内存的指针
返回值是void

为什么重载operator delete的时候，参数是一个void*?

这是因为它是在调用析构函数后得到的指针。

				?

									//重载operator new

									//1.必须有一个size_t的参数，该参数将接收要申请开辟空间的大小

									//2.返回值是一个void*

									//3.返回一个指向对象的指针，该对象的长度等于或大于所申请的长度

									//4.如果分配失败。不仅仅要返回一个0，还需产生一个异常信息

									void* operator new(size_t sz)

									{

									    cout << "new %d Bytes" << sz << endl;

									    void* p = nullptr;

									    //不需要强制类型转换，因为malloc返回的就是void*

									    p = malloc(sz);

									    if (nullptr == p)

									    {

									        cout << "new fail\n" << endl;

									    }

									    return p;

									}

									//重载operator delete

									//1.返回值为void

									//2.参数是一个指向由operator new()返回的void*的指针

									void operator delete(void* rp)

									{

									    cout << "operator delete" << endl;

									    free(rp);

									}

重载类专属

				?

									//重载ListNode专属的operator new

									struct ListNode

									{

									    ListNode* _next;

									    ListNode* _prev;

									    int _data;

									    void* operator new(size_t n)

									    {

									        void* p = nullptr;

									        p = allocator<ListNode>().allocate(1);

									        cout << "memory pool allocate" << endl;

									        return p;

									    }

									    void operator delete(void* p)

									    {

									        allocator<ListNode>().deallocate((ListNode*)p, 1); //内存池--空间适配器

									        cout << "memory pool deallocate" << endl;

									    }

									};

									class List

									{

									public:

									    List()

									    {

									        _head = new ListNode;

									        _head->_next = _head;

									        _head->_prev = _head;

									    }

									    ~List()

									    {

									        ListNode* cur = _head->_next;

									        while (cur != _head)

									        {

									            ListNode* next = cur->_next;

									            delete cur;

									            cur = next;

									        }

									        delete _head;

									        _head = nullptr;

									    }

									private:

									    ListNode* _head;

									};

									int main()

									{

									    List l;

									    return 0;

									}

定位new表达式

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

使用的格式：

new (place_address) type 或者 new (place_address) type (initializer-lost) place_address必须是一个指针，initializer-list是初始化列表。

				?

									//例如

									class Test

									{

									public:

									    Test()

									        : _data(0)

									    {

									        cout << "Test():" << this << endl;

									    }

									    ~Test()

									    {

									        cout << "~Test():" << this << endl;

									    }

									private:

									    int _data;

									};

									int main(void)

									{

									    // pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行

									    Test* pt = (Test*)malloc(sizeof(Test));

									    //定位new

									    new(pt) Test; // 注意：如果Test类的构造函数有参数时，此处需要传参

									    return 0;

									}