文章目录
C/C++内存分布
【说明】
-
栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
-
内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。
用户可使用系统接口创建共享共享内存，做进程间通信。
-
堆用于程序运行时动态内存分配，堆是可以上增长的。
-
数据段–存储全局数据和静态数据。
-
代码段–存储可执行的代码/只读常量
注意：
在堆区开辟空间，后开辟的空间地址不一定比先开辟的空间地址高。
因为在堆区，后开辟的空间也有可能位于前面某一被释放的空间位置。
C++内存管理方式
C语言中的内存管理方式
malloc
malloc函数的功能是开辟指定字节大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL。
传参时只需传入需要开辟的字节个数。
calloc
calloc函数的功能也是开辟指定大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL。
calloc函数传参时需要传入开辟的内存用于存放的元素个数和每个元素的大小。
calloc函数开辟好内存后会将空间内容中的每一个字节都初始化为0。
realloc
realloc函数可以调整已经开辟好的动态内存的大小，第一个参数是需要调整大小的动态内存的首地址，第二个参数是动态内存调整后的新大小。realloc函数与上面两个函数一样，如果开辟成功便返回开辟好的内存的首地址，开辟失败则返回NULL。
realloc函数调整动态内存大小的时候会有三种情况：
1、原地扩：需扩展的空间后方有足够的空间可供扩展，此时，realloc函数直接在原空间后方进行扩展，并返回该内存空间首地址（即原来的首地址）。
2、异地扩：需扩展的空间后方没有足够的空间可供扩展，此时，realloc函数会在堆区中重新找一块满足要求的内存空间，把原空间内的数据拷贝到新空间中，并主动将原空间内存释放（即还给操作系统），返回新内存空间的首地址。
3、扩充失败：需扩展的空间后方没有足够的空间可供扩展，并且堆区中也没有符合需要开辟的内存大小的空间。结果就是开辟内存失败，返回一个NULL。
free
free函数的作用就是将malloc、calloc，realloc函数申请的动态内存空间释放，其释放空间的大小取决于之前申请的内存空间大小。
void test_1()
{
int* p1 = (int*)malloc(sizeof(int));
free(p1);
// 1.malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int) * 10);
// 这里需要free(p2)吗？
//这里不需要free(p2)，p3是对p2的扩容
//若原地址的空间够，那p3和p2就指向同一块空间
//若原地址空间不够，realloc会先释放掉p2的那块空间
//在新的地方重新开辟一块空间
free(p3);
}
C++中的内存管理方式
申请内置类型空间
动态申请一个某类型的空间
//动态申请单个int类型的空间
int* p1 = new int; //申请
delete p1; //销毁
动态申请多个某类型的空间
//动态申请10个int类型的空间
int* p3 = new int[10]; //申请
delete[] p3; //销毁
动态申请一个某类型的空间并初始化
//动态申请单个int类型的空间并初始化为10
int* p5 = new int(10); //申请 + 赋值
delete p5; //销毁
动态申请多个某类型的空间并初始化
//动态申请5个int类型的空间并初始化为0到4
//C++11支持,未传值的部分赋值0
int* p7 = new int[5]{0, 1, 2}; //申请 + 赋值
delete[] p7; //销毁
申请自定义类型空间
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
new和delete的用法
//malloc：在堆上申请内存空间
//失败返回NULL，故malloc需要检查返回值
A* p1 = (A*)malloc(sizeof(A));
//释放空间
free(p1);
//new ：1.先在堆上申请内存空间 2.再调用默认构造函数初始化
//new 失败不需要检查返回值，失败抛异常
A* p2 = new A;
//没有默认构造函数的情况下，程序编译会报错
//但可通过手动传参，使对象初始化
A* p3 = new A(10);
//delete：1.先调用析构函数清理对象中的资源，2.再释放空间
//后定义的先析构
delete p2;
delete p3;
//结论 new/delete是为自定义类型准备的
//不仅在堆上申请出来，还会调用构造和析构初始化和清理
A* p4 = new A[10];
delete[] p4;
//c++11支持
A* p5 = new A[2]{ 1,2 };
//在堆上申请空间与计算机的配置无关
//无论硬件内存有多少，每个进程申请的空间都是虚拟地址空间，
总结
-
针对内置类型，new/delete只是用法简化了，与malloc/free没有本质区别。
-
new/delete是操作符，而malloc/free是函数
对于自定义类型：
-
new ：1.先在堆上申请内存空间 2.再调用默认构造函数初始化，new 失败不需要检查返回值，失败抛异常
-
delete：1.先调用析构函数清理对象中的资源，2.再释放空间
operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，
new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
operator new和operator delete的用法和malloc和free的用法完全一样，其功能都是在堆上申请和释放空间。
int* p1 = (int*)operator new(sizeof(int)* 10); //申请
operator delete(p1); //销毁
//等价于
int* p2 = (int*)malloc(sizeof(int)* 10); //申请
free(p2); //销毁
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
operator delete: 该函数最终是通过free来释放空间的
重载一个类专属的operator new
默认情况下 operator new 使用全局库里面的，每个类都可以去实现自己专属的operator new ，当去new 这个类对象时，他就会去调用自己实现的operator new ，不会去调用全局库里面的operator new。
注意：这里的重载不是运算符的那种重载，也不是函数重载，可以认为是operate new的一个特性
应用场景：
如果一个节点要频繁的开辟，就要不断的找系统申请内存，就会有内存碎片和效率的问题
池化技术可以解决频繁找系统申请内存的问题
内存池就是先在内存中一次性申请大一点的空间，若有节点要频繁的开辟，那可以直接向内存池申请，不用向操作系统申请
这样提高了操作系统的效率
struct ListNode
{
int _val;
ListNode* _next;
//内存池
static allocator<ListNode>alloc;
//专属的operate new不会去内存中申请内存，而是在内存池中申请内存
//这里的重载不是运算符的那种重载，也不是函数重载，可以认为是operate new的一个特性
void* operator new(size_t n)
{
cout << "operator new -> STL内存池allocator申请" << endl;
void* obj = alloc.allocate(1);
return obj;
}
void operator delete(void* ptr)
{
cout << "operator delete -> STL内存池allocator申请" << endl;
alloc.deallocate((ListNode*)ptr, 1);
}
sturct ListNode(int val)
:_val(val)
,_next(nullptr)
{}
};
allocator<ListNode> ListNode::alloc;
void test_3()
{
//频繁申请ListNode---想提高效率，申请LisNode时，不去malloc，而是走自己定制的内存池
ListNode* node1 = new ListNode(1);
ListNode* node2 = new ListNode(2);
ListNode* node3 = new ListNode(3);
}
new和delete的实现原理
内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似
不同的地方是：
new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，
而且new在申请空间失败时会抛异常，malloc会返回NULL。
自定义类型
new的原理
- 调用operator new函数申请空间
- 在申请的空间上执行构造函数，完成对象的构造
delete的原理
- 在空间上执行析构函数，完成对象中资源的清理工作
- 调用operator delete函数释放对象的空间
new T[N]的原理
-
调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
-
在申请的空间上执行N次构造函数
delete[]的原理
- 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
- 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间
定位new表达式
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
A* p6 = (A*)malloc(sizeof(A));
if (p6==nullptr)
{
perror("malloc fail");
}
//定位new：在已分配的原始内存空间中调用构造函数初始化一个对象
//为已经分配内存空间的p6 调用类A的构造函数进行初始化
new(p6)A;
//括号中给的参数是p6要被初始化的值，也可以不给，这样p6就会被初始化为默认值
new(p6)A(10);
常见面试题
malloc/free和new/delete的区别
共同点：
都是从堆上申请空间，并且需要用户手动释放。
不同点：
-
malloc和free是函数，new和delete是操作符
-
malloc申请的空间不会初始化，new可以初始化
-
malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
如果是多个对象，[]中指定对象个数即可。
-
malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
-
malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要判空，但是new需要捕获异常
-
申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，
new ：1.先在堆上申请内存空间 2.再调用默认构造函数初始化
delete：1.先调用析构函数清理对象中的资源，2.再释放空间
内存泄漏
什么是内存泄露？
内存泄漏是指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害
长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
void MemoryLeaks()
{
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 2.异常安全问题
int* p3 = new int[10];
Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
delete[] p3;
}
内存泄漏的分类
1、堆内存泄漏(Heap Leak)
堆内存指的是程序执行中通过malloc、calloc、realloc、new等从堆中分配的一块内存，用完后必须通过调用相应的free或者delete释放。假设程序的设计错误导致这部分内容没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap
Leak。
2、系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
如何避免内存泄漏
-
工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
-
采用RAII思想或者智能指针来管理资源。
-
有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
-
出问题了使用内存泄漏工具检测。
解决方案：
1、事前预防型。如智能指针等。
2、事后查错型。如泄漏检测工具。
3345
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
