目录

〇、C语言的动态内存分配方式

一、C++的动态内存分配方式

1. 什么是C++的动态内存分配？

2. 为什么需要C++的动态内存分配？

a. new的优势

b. new的不足

c. delete的优势

d. 总结

3. 怎么使用new和delete?

a. 对于内置类型

b. 对于自定义类型 

c. 为什么new不需要检查失败？

4. new和delete的实现原理

5. new[]和delete[]的实现原理

7. 重载operator new与operator delete(了解)

8. 定位new表达式(placement-new) （了解）

9. malloc/free和new/delete的区别

〇、C语言的动态内存分配方式

//使用new动态的申请内存创建int变量，不初始化
int* a1 = new int;
//使用new动态的申请内存创建int变量，使用括号初始化
int* a2 = new int(2);//使用new动态的申请内存创建int数组，不初始化
int* b1 = new int[10];
//使用new动态的申请内存创建int数组，使用{}初始化(C++11后引入)
int* b2 = new int[10]{ 1, 2 ,3, 4 };//delete是关键字直接用就可以
//使用delete释放单个的动态变量
delete a1;
delete a2;
//使用delete[]释放连续的动态数组
delete[] b1;
delete[] b2;

b. 对于自定义类型 

对于自定义类型，如果不显示初始化，那么会调用其默认构造函数进行初始化。

class A {
private:int _a;int _b;
public:A(int a = 1, int b = 1): _a(1), _b(0){_a = a;_b = b;}
};// 用new创建一个自定义类型对象不初始化，编译器会调用默认构造函数
A* p0 = new A;
// 用new创建一个自定义类型对象并显示初始化
A* p1 = new A(1, 2);// 用delete销毁自定义类型对象
delete p0;
delete p1;   

C++11后，可以用以下四种方式在new时对类数组初始化：

// 创建一个自定义类型对象数组（不显示初始化，编译器调用默认构造函数初始化）
A* p2 = new A[2];// 创建一个自定义类型对象数组并初始化（C++11后支持）
A* p3 = new A[2]{ 1, 2 }; // 每个数对应一个对象，初始化对应对象的第一个成员
A* p4 = new A[2]{ (1,2,3,4,5)};  // 每个()对应一个对象，用()中的最后一个数初始化对应对象的第一个成员
A* p5 = new A[2]{ {1,2}, {3,4} }; // 每个{}对应一个对象，按顺序初始化对象成员
A* p6 = new A[2]{ A(1, 2), A(3, 4)}; // 每个构造函数对应一个对象delete[] p2;
delete[] p3;
delete[] p4;
delete[] p5;
delete[] p6;

c. 为什么new不需要检查失败？

 malloc和new对于开辟空间失败的处理方式不同：
        malloc是一个函数，失败返回NULL；new是一个操作符，仅在动态内存分配成功时返回一个指针，分配失败只会抛异常不会返回空指针（除非使用了std::nothrow参数）。使用try{}catch{}语句来捕获并处理异常。

        new和delete是用户进行动态内存申请和释放的操作符，new在底层是调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。operator new 和operator delete并不是在重载new和delete运算符，而是系统提供的全局函数用来申请和释放空间。以下是对该语句进行反汇编的结果：

---

当然new也不仅仅只是调用operator new全局函数来申请空间，还会调用构造函数，申请空间失败时还会抛异常：

---

所以在c++中更推荐使用new来动态申请空间，一是能同时调用构造函数，二是出错时抛异常，这样符合C++的失败机制。

5. new[]和delete[]的实现原理

        operator new 实际也是通过malloc来申请空间，如果 malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施 就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

---

        new[ ]的底层是先调用operator new[ ]，再调用 operator new，完成N个对象的空间申请，最后调用N次构造函数。
        而delete[ ]的底层是先调用N次析构函数，完成对N个对象的清理，然后调用operator delete[ ]，再调用 operator delete来释放空间。

7. 重载operator new与operator delete(了解)

        一般情况下不需要对 operator new 和 operator delete进行重载，除非在申请和释放空间时候有某些特殊的需求。比如：在使用new和delete申请和释放空间时，打印一些日志信息，可以简单帮助用户来检测是否存在内存泄漏。或是改用内存池，而不直接从堆上申请空间。

        new一个类时，看有没有自己的专属operator new，有，优先使用专属operator new，否则使用默认的全局operator new。

---

当频繁调用new时，想提高效率，不再走默认operator new中的malloc，而是自己定制一个内存池。使用内存池的优势在于，一次性向堆申请一大块空间A，以后要开辟空间直接在 A中拿即可，省时省力，而每次使用malloc，都要先申请，然后在堆中找一块合适的空间。

8. 定位new表达式(placement-new) （了解）

定位new的作用？

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

---

使用格式：

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

        p必须是一个指针，type(initializer-list)是就是构造函数。意思是在p指向的空间创建一个对象。

---

使用场景：

        定位new允许开发者在预先分配的内存中构造对象，而不是让new运算符自动在堆上分配内存。定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

#include <iostream>  
#include <new> // 包含定位new的头文件  class MyClass {  
public:  MyClass(int value) : value_(value) {  std::cout << "MyClass constructed with value " << value_ << std::endl;  }  ~MyClass() {  std::cout << "MyClass destroyed" << std::endl;  }  void printValue() const {  std::cout << "Value: " << value_ << std::endl;  }  private:  int value_;  
};  int main() {  // 分配足够的内存来存储MyClass对象  char buffer[sizeof(MyClass)];  // 使用定位new在buffer中构造对象  MyClass* obj = new (buffer) MyClass(42);  // 调用对象的成员函数  obj->printValue();  // 手动调用析构函数，因为定位new不会调用delete  obj->~MyClass();  return 0;  
}

9. malloc/free和new/delete的区别

malloc/free和new/delete的共同点是:

• 都是从堆上申请空间，并且需要用户手动释放。

不同的地方是:

1. maloc和free是函数，new和delete是操作符。
2. malloc申请的空间不会初始化，new可以初始化。
3. malloc的返回值为void*，在使用时必须强转；new不需要，因为new后跟的是空间的类型。
4. malloc申请空间失败时，返回的是NULL，因此使用时必须判空；new不需要，但是new需要捕获异常。
5. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[ ]中指定对象个数即可。
6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。

------------------------END-------------------------

才疏学浅，谬误难免，欢迎各位批评指正。