当前位置：首页 > news >正文

【C++】动态内存管理

news 2025/8/17 6:36:19

一. C&C++内存分布

栈：非静态局部变量/函数参数/返回值等，栈是向下增长的。
内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux详细讲解）
堆：程序运行时动态内存分配，堆是可以上增长的。
数据段、静态区：存储全局数据和静态数据。
代码段、常量区：可执行的代码/只读常量。

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{static int staticVar = 1;int localVar = 1;int num1[10] = { 1,2,3,4 };
}

globalVar、staticGlobalVar、staticVar在静态区
localVar、num1在栈

void Test
{char char2[] = "abcd";const char* pChar3 = "abcd"; // 常量字符串，如果不加const则权限放大，报错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);
}

char2、*char2、pChar3、ptr1在栈
*pChar3在常量区
*ptr1在堆

二. C++内存管理方式

C主要靠malloc/calloc/realloc/free等函数手段完成
C++通过 new 和 delete 操作符进行动态内存管理

1. 内置类型

内置类型C&C++没太大区别。
C++的 new delete 不用算多少字节、不用强转

new、delete 申请和释放的是单个元素的空间
new[ ]、delete[ ] 申请的是连续空间

int main()
{// Cint* p1 = (int*)malloc(sizeof(int)); // 随机值free(p1);// C++ 动态申请一个int类型的空间int* p2 = new int; // 随机值delete p2;// Cint* p3 = (int*)malloc(sizeof(int)*10); // 全是随机值free(p3);// C++ 动态申请10个int类型的空间int* p4 = new int[10]; // 全是随机值delete[] p4;// C++ 动态申请一个int类型的空间并初始化为10int* p5 = new int(10);delete p5;int* p6 = new int[10]{1,2,3}; // 其余是0delete[] p6;return 0;
}

2. 自定义类型

C：malloc 只是单纯开空间，不初始化；free 不清理资源
C++：new 出来就调用构造函数初始化；delete 调用析构函数

struct ListNode
{int _val;struct ListNode* _next;ListNode(int x) // 构造函数:_val(x), _next(NULL){}
};struct ListNode* BuyListNode(int x)
{// 单纯开空间struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));// 检查newnode->_next = NULL;newnode->_val = x;return newnode;
}int main()
{struct ListNode* n1 = BuyListNode(1);struct ListNode* n2 = BuyListNode(2);struct ListNode* n3 = BuyListNode(3);// 开空间+调用构造函数初始化ListNode* nn1 = new ListNode(1);ListNode* nn2 = new ListNode(2);ListNode* nn3 = new ListNode(3);return 0;
}

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*)malloc(sizeof(A));A* p2 = new A(1);free(p1);delete p2;A* p5 = (A*)malloc(sizeof(A) * 10);A* p6 = new A[4];free(p5);delete[] p6;return 0;
}

p6 全初始化成 0，因为构造函数给了缺省参数

如果没有默认构造函数

class A
{
public:A(int a): _a(a){cout << "A():" << this << endl;}~A(){cout << "~A():" << this << endl;}private:int _a;
};int main()
{// A* p6 = new A[4]; // 报错：“A”: 没有合适的默认构造函数可用A* p6 = new A[4]{ 1,2,3,4 };A* p6 = new A[4]{ A(1),A(2),A(3),A(4) }; // 给4个匿名对象delete[] p6;return 0;
}

如果多个参数

class A
{
public:A(int a, int b): _a(a){cout << "A():" << this << endl;}A(const A& aa): _a(aa._a){cout << "A(const A& aa):" << this << endl;}~A(){cout << "~A():" << this << endl;}private:int _a;
};int main()
{A* p2 = new A(1, 1);delete p2;A* p6 = new A[4]{ A(1,1),A(2,2),A(3,3),A(4,4) };delete[] p6;return 0;
}

构造+拷贝构造-->优化为直接构造

此时，没有默认构造，必须传4个匿名对象。如果给了缺省参数，有了默认构造，可以少传

三. new delete 底层

operator new、operator delete 函数：

他们不是运算符重载，是库里的全局函数。他们不是给程序员用的，是给 new、delete用的

C语言处理失败，返回错误码。C语言喜欢用 malloc，申请失败返回 0（NULL）
C++处理失败，抛异常

C++源代码中：
operator new 实际也是通过malloc来申请空间。若malloc申请空间成功就直接返回；否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常
operator delete 最终是通过free来释放空间的（malloc、free只是隐藏起来了，不是没用了）

new[ ]：
1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
2. 在申请的空间上执行N次构造函数

delete[ ]：
1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

用 Stack 理解

int main()
{// 申请一个堆上的栈对象Stack* p1 = new Stack;delete p1;return 0;
}

用 new 就不用加 if (NULL==_array) 这种检查了。new 失败抛异常，我们在所有 new 的地方 try catch捕获就行

int main()
{try{// 申请一个堆上的栈对象Stack* p1 = new Stack;delete p1;}catch (const exception& e){cout << e.what() << endl;}return 0;
}

这里的 try catch 不仅能捕获 main 函数里的；还能捕获构造函数里面的异常
只要是在范围内，直接、间接调用的都可以捕获

四. 定位 new 表达式（placement-new）

new 的其他操作

定位new表达式是对已有空间调用构造函数初始化一个对象

格式：new (指针) 类型 或 new (指针) 类型(类型的初始化列表)

int main()
{// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行A* p1 = (A*)malloc(sizeof(A));// 显示调用构造函数new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参 new(p1)A(1);// 显示调用析构函数p1->~A();free(p1);// 自定义类型的对象才能自动调用构造、析构函数。p1是内置类型，必须显示调用析构return 0;
}