一. 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()
{
// C
int* p1 = (int*)malloc(sizeof(int)); // 随机值
free(p1);
// C++ 动态申请一个int类型的空间
int* p2 = new int; // 随机值
delete p2;
// C
int* p3 = (int*)malloc(sizeof(int)*10); // 全是随机值
free(p3);
// C++ 动态申请10个int类型的空间
int* p4 = new int[10]; // 全是随机值
delete[] p4;
// C++ 动态申请一个int类型的空间并初始化为10
int* p5 = new int(10);
delete p5;
int* p6 = new int[10]{1,2,3}; // 其余是0
delete[] 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;
}
应用场景：池化技术：内存池、线程池、连接池
定位new表达式 在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化
需要频繁申请和释放内存。new 是直接找堆，路径长、麻烦
建池子，提前申请一大块内存放到池子里。要的时候直接找池子要，池子没了再去找堆。效率高
五. 内存泄露
这个部分小编会在后面单独出一期内容
本篇的分享就到这里了，感谢观看，如果对你有帮助，别忘了点赞+收藏+关注。
小编会以自己学习过程中遇到的问题为素材，持续为您推送文章