完整教程：【C++】内存管理

new与delete

• 一、C/C++内存管理
• 二、C语言中存管理
• 三、C++内存管理方式
• • 1、new和delete操作我自定义类型
  • • 1.1 内置类型
    • 1.2 类类型
    • 1.3 链表类型
• 四、operator new与operator delete函数
• • 1、捕捉异常
• 五、new和delete的实现原理
• • 1、内置类型
  • 2、自定义类型
• 六、malloc/free和new/delete的区别

一、C/C++内存管理

1. 栈：存储非静态局部变量、函数参数、返回值等，空间自动管理，向下增长
2. 内存映射段：用于高效 I/O 操作和进程间共享内存
3. 数据段：全局数据、静态数据
4. 代码段：可执行代码、常量

二、C语言中存管理

C语言使用malloc/calloc/realloc/free进行动态内存管理

void test()
{
int* p1 = (int*)malloc(4 * sizeof(int));  // 分配空间，不初始化
int* p2 = (int*)calloc(4, sizeof(int));   // 分配空间并初始化为0
int* p3 = (int*)realloc(p2, 10 * sizeof(int)); // 重新分配空间
free(p1);
free(p3);  // realloc后只需释放新指针
}

1. malloc在堆上手动申请个空间
2. calloc在手动申请空间的基础上进行初始化为0
3. realloc申请比之前申请更大的新空间，将之前申请的旧空间拷贝到新空间中，然后再销毁旧空间

三、C++内存管理方式

1、new和delete操作我自定义类型

1.1 内置类型

int main()
{
// 基本用法
int* p1 = new int;         // 分配单个int空间
int* p2 = new int[10];     // 分配10个int的数组
// 初始化
int* p3 = new int(0);      // 分配并初始化为0
int* p4 = new int[10]{0};  // 数组初始化，剩余元素为0
int* p5 = new int[10]{1,2,3,4,5}; // 部分初始化
// 释放空间
delete p1;
delete[] p2;
delete p3;
delete[] p4;
delete[] p5;
return 0;
}

1.2 类类型

对于自定义类型，new和delete会自动调用构造函数和析构函数：

//类类型
//----------------------------------------------------------------------------
#include<iostream>
  using namespace std;
  class A
  {
  public:
  A(int a1, int a2 = 0)
  :_a1(a1)
  ,_a2(a2)
  {
  cout << "A(int a1 = 0, int a2 = 0)" << endl;
  }
  A(const A& aa)
  :_a1(aa._a1)
  {
  cout << "A(const A& aa)" << endl;
  }
  A& operator=(const A& aa)
  {
  _a1 += 100;
  return *this;
  }
  private:
  int _a1 = 1;
  int _a2 = 2;
  };
  int main()
  {
  A* p1 = new A(1); //必须默认构造
  A* p2 = new A(2, 2);
  //A* p3 = new A[3]; //默认默认构造则报错
  //第一种写法
  A aa1(1, 1);
  A aa2(2, 2);
  A aa3(3, 3);
  A* p3 = new A[3]{ aa1, aa2, aa3 };//拷贝构造
  //第二种写法:匿名构造
  //编译器直接优化成直接构造
  A* p4 = new A[3]{ A(1, 1), A(2, 2), A(3, 3) };
  //第三种写法：隐式类型转换
  //编译器直接优化成直接构造
  A* p5 = new A[3]{ {1,1},{2,2},{3,3} };
  return 0;
  }
  //----------------------------------------------------------------------------

1.3 链表类型

//----------------------------------------------------------------------------
struct ListNode
{
int val;
ListNode* next;
ListNode(int x)
:val(x)
,next(nullptr)
{ }
};
int main()
{
//与C语言的区别是：自动调用构造函数和析构函数
A* p1 = new A;
A* p2 = new A(1);
delete p1;
delete p2;
//用new申请类类型和自定义类型的空间：自动初始化与析构
ListNode* n1 = new ListNode(1);
ListNode* n2 = new ListNode(1);
ListNode* n3 = new ListNode(1);
ListNode* n4 = new ListNode(1);
n1->next = n2;
n2->next = n3;
n3->next = n4;
return 0;
}
//----------------------------------------------------------------------------

四、operator new与operator delete函数

new和delete时用户进行动态内存申请和释放的操作符，operator new和operator delete时系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
operator new实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete最终是通过free来释放空间的

1、捕捉异常

//----------------------------------------------------------------------------
void func()
{
int n = 1;
while (1)
{
void* p1 = new char[1024 * 1024];
cout << p1 << "->" << n << endl;
  ++n;
  }
  }
  int main()
  {
  try
  {
  func();
  }
  catch (const exception& e)
  {
  cout << e.what() << endl;
  }
  return 0;
  }
  //----------------------------------------------------------------------------

五、new和delete的实现原理

1、内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的连续空间，而且new在申请空间失败是会抛异常，malloc会返回NULL。

#include<iostream>
  using namespace std;
  int main()
  {
  //内置类型
  // 
  // 
  //不会报错(内核是)：
  //new operator[]最终调用malloc
  //delete operator[]最终调用free
  int* p1 = new int[10];  // -> malloc
  delete p1;				// -> free
  free(p1);
  return 0;
  }

2、自定义类型

• 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来释放空间

#include<iostream>
  using namespace std;
  class A
  {
  public:
  ~A()
  {
  cout << "~A()" << endl;
  }
  private:
  int _a1 = 1;
  int _a2 = 2;
  };
  class B
  {
  private:
  int _b1 = 1;
  int _b2 = 2;
  };
  int main()
  {
  //自定义类型
  // 
  // 
  //因为B* p1没有调用析构函数，析构被编译器优化掉
  //因为没有析构，前面没有开4个字节，一共80个字节且释放地方相同，所以可以正常释放
  B* p1 = new B[10];
  delete p1;
  //这里由于调用了析构函数，在创建的80字节内存前加了4字节，一共有84字节
  //这里只用delete却没有用delete[]，会让p2指向第80字节，释放空间时因为释放位置不对而崩溃
  A* p2 = new A[10];
  delete p2;
  }

六、malloc/free和new/delete的区别

特性	malloc/free	new/delete
性质	函数	操作符
初始化	不初始化	可初始化
参数	需要手动计算大小	只需指定类型
返回值	void*，需强转	具体类型指针
错误处理	返回 NULL	抛异常
自定义类型	只分配 / 释放空间	会调用构造 / 析构函数

共同点是：

1. 都是从堆上申请空间，并且需要用用户手动释放。不同的地方是：

不同点是：

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