C++ ---内存管理
Posted L_add
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++ ---内存管理相关的知识，希望对你有一定的参考价值。
内存管理
C/C++内存分布
#include <iostream>
using namespace std;
void f2()
{
int b = 0;
cout<< "b:" << &b << endl;
}
void f1()
{
int a = 0;
cout << "a:"<< &a << endl;
f2();
}
int main()
{
f1();
return 0;
}
int main()
{
int* p1 = (int*)malloc(4);
int* p2 = (int*)malloc(4);
cout << "p1:" << p1 << endl;
cout << "p2:" << p2 << endl;
return 0;
}
动态申请中一般情况下，后申请比先申请的大
int globalvar = 1;
static int staticgobalvar = 1;
void Test()
{
static int staticvar = 1;
int localvar = 1;
int num[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
char* pchar3 = "abcd";
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);
}
//选项 A栈 B堆 C数据段(静态区) D代码段(常量区)
// globalvar:C staticgobalvar:C
//staticvar:C localvar:A
//num:A
//char2:A *char2:A
//pchar3:A *pchar:D
//ptr1:A *ptr1:B
//sizeof(num) = 40 strlen(char2) = 4
//sizeof(char2)= 5 strlen(pchar3)=4
//sizeof(pchar3)= 4 sizeof(ptr1) = 4
//
C语言中动态内存的管理方式
void Test()
{
int* p1 = (int*)malloc(sizeof(int));
free(p1);
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int)* 10);
//不需要free(p2)
free(p3);
//malloc堆上动态开空间
//calloc堆上动态开空间+初始化成0 = malloc+memset
//realloc针对已有空间扩容(原地扩容和异地扩容)
//原地扩容-》后面有足够的空间
//异地扩容-》 后面没有足够的空间
}
C++中动态内存管理
int main()
{
//new/delete和malloc/free针对内置类型没有差别
//new/delete和new[]/delete[]一定要匹配
//申请一个10个int的数组
int* p1 = (int*)malloc(sizeof(int)* 10);
int* p2 = new int[10];
free(p1);
delete[]p2;
//申请单个对象
int* p3 = (int*)malloc(sizeof(int));
int*p4 = new int;
free(p3);
delete p4;
//动态申请一个int类型的空间并初始化为10
int* p5 = new int(10);
delete p5;
return 0;
}
struct ListNode
{
ListNode* _next;
ListNode* _prev;
int _val;
ListNode(int val = 0)
:_next(nullptr)
, _prev(nullptr)
, _val(val){}
};
int main()
{
// C malloc只是开空间 free释放空间
struct ListNode* p1 = (struct ListNode*)malloc(sizeof(ListNode));
free(p1);
//C++ new 针对自定义类型：开空间+构造函数初始化
// delete针对自定义类型：析构函数清理+释放空间
ListNode* p2 = new ListNode;
delete p2;
ListNode* p3 = new ListNode(5);//相当于创建新结点
delete p3;
ListNode* arr4 = new ListNode[4]{1, 2, 3, 4};
delete[]arr4;
//delete arr4 不匹配
return 0;
}
总结：
- C++如果申请内置类对象或数组，malloc和new没有区别
- 如果是自定义类型，new是开空间+初始化；delete是析构清理+释放空间
- 建议在C++中使用new和delete
operator new与operator delete函数
函数
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层调用operator delete全局函数来释放空间
new -> 调用operator new + 构造函数-》调用malloc+失败抛异常机制
struct ListNode
{
ListNode* _next;
ListNode* _prev;
int _val;
ListNode(int val = 0)
:_next(nullptr)
, _prev(nullptr)
, _val(val){}
};
int main()
{
//用法跟malloc/new一样，功能都是在堆上申请释放空间
ListNode* p1 = (ListNode*)malloc(sizeof(ListNode));
free(p1);
//失败的处理方式不一样，malloc失败返回NULL，operator new失败后抛出异常
ListNode* p2 = (ListNode*)operator new(sizeof(ListNode));
operator delete (p2);
void* p3 = malloc(0x7fffffff);
if (p3 == NULL)
cout << "malloc fail" << endl;
//捕获异常
try
{
void* p4 = operator new(0x7fffffff);
}
catch (exception&e)
{
cout << e.what() << endl;
}
return 0;
}
operator new实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则抛异常。operator delete是通过free来释放空间的
operator new与operator delete的类专属重载
提高效率
struct ListNode
{
ListNode* _next;
ListNode* _prev;
int _val;
//不调用全局-》类中重载专属operator new/delete
//池化技术（提高效率）
//内存池，进程池，线程池，连接池...
void* operator new(size_t n)
{
void* p = nullptr;
p = allocator<ListNode>().allocate(1);
//allocate STL中空间配置器，一个简单的内存池
cout << "memory pool allocate" << endl;
return p;
}
void* operator delete (size_t n)
{
allocator<ListNode>().dallocate((ListNode*)p,1);
cout << "memory pool dallocate" << endl;
}
ListNode(int val = 0)
:_next(nullptr)
, _prev(nullptr)
, _val(val){}
};
int main()
{
//调用的是全局的operator new和operator delete
ListNode* p = new ListNode(1);
delete p;
return 0;
}
new和delete的实现原理
内置类型
如果申请的是自定义类型的空间，new/malloc,delete/free基本相似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]/delete[]申请/释放的是连续空间，而且new在申请空间失败会抛出异常，malloc会返回NULL
自定义类型
new的原理：
- 调用operator new函数申请空间
- 在申请空间上执行构造函数，完成对象的构造
delete的原理：
- 在空间上执行析构函数，完成对象中资源的清理工作
- 调用operator delete函数释放对象的空间
new[N]的原理：
- 调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对象空间的申请
- 在申请的空间上执行N次构造函数
delete[N]的原理：
- 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
- 调用operator delete[]释放空间，实际上在operator delete[]中调用operator delete来释放空间
定位new表达式(placement-new)
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象
格式：
new(place_address)type 或者new(place_address)type(initializer-list),place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以自定义类型的对象，需要使用new的定义表达式进行显示构造函数进行初始化。
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A():" << this<< endl;
}
~A()
{
cout << "~A():" <<this << endl;
}
private:
int _a;
};
int main()
{
//A* p = (A*)malloc(sizeof(A));
//等价于 A* p = new A
A* P = (A*)operator new(sizeof(A));
new(p)A;//new(p)A(3)
//定位new,placement-new,显示调用构造函数初始化这块对象空间
//等于 delete p
P->~A();//析构函数可以调用
operator delete (p);
return 0;
}
常见试题
malloc/free和new/delete的区别
malloc/free和new/delete的共同点：都从堆上申请空间，并且需要用户手动释放
不同点：
- malloc和free是函数，new和delete是操作符
- malloc申请的空间不会初始化，new可以
- malloc申请空间时，需要手动计算空间大小并传递，new只需在其后加上空间类型即可，如果是多个对象，[]中指定对象个数即可
- malloc返回值为void*,在使用时必须强转类型,new不需要，因为new后有空间类型
- malloc申请空间失败时，返回值是NULL，因此使用时必须判空，new不需要，但new需要捕获异常
- 申请自定义类型对象时，malloc/free只会开辟/释放空间，而new在申请空间后会调用析构函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中的资源清理
内存泄漏
什么是内存泄漏？
内存泄漏是指因为疏忽或错误造成程序未能释放已经不在使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成内存浪费
内存泄漏的危害：
长期运行的程序出现内存泄漏，影响很大，如：操作系统，后台服务等等，出现内存泄漏会导致相应越来越慢，最终卡死
内存泄漏是指针丢了,malloc/new申请空间本质是申请一块空间的使用权，free/delete释放空间的本质是把内存的使用权交还给系统
内存泄漏的分类
堆内存泄漏
堆内存指的是程序执行中依据需要分配通过malloc/calloc/realloc/new等从堆中分配的一块内存，用完后必须通过调用相应的free或者delete删掉，假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak
系统资源泄漏
指程序使用系统分配的资源，比如套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定
如何避免内存泄漏
1.工程前良好设计规范，养成良好的编码规范，申请的内存空间要匹配的去释放(ps:这个是理想状态，但如果异常，就算注意释放，也会出问题，需要下一条智能指针来管理才有保证)
2.采用RAII思想或者智能指针来管理资源
3.公司内部规范使用内部实现的私有内存管理库，这种库自带内存泄漏的功能选项。
4.使用检测内存泄漏的工具
如何一次在堆上申请4G的内存？
//在堆上申请4G的内存
int main()
{
void* p = new char[0xfffffffful];
cout << "new:" << p << endl;
return 0;
}
以上是关于C++ ---内存管理的主要内容，如果未能解决你的问题，请参考以下文章