【一起来学C++】————(5)内存管理(上)
C/C++内存分布
我们先来看下面的一段代码和相关问题
int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[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);
}
【说明】
- 栈又叫堆栈,
非静态局部变量/函数参数/返回值
等等,栈是向下增长的。 - 内存映射段是高效的I/O映射方式,用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存,做进程间通信。(Linux课程如果没学到这块,现在只需要了解一下)
- 堆用于程序运行时
动态内存分配
,堆是可以上增长的。 - 数据段–存储
全局数据和静态数据
。 - 代码段–可执行的
代码/只读常量
。
C语言中动态内存管理方式
- 运用malloc/calloc/realloc等来申请空间,使用free来销毁,那么malloc、calloc、realloc有什么区别?
1、malloc
的函数原型是void* malloc(size_t size)
;它实现的功能是在内存的动态存储区分配一块长度为size字节的连续区域
,参数size为需要的内存空间的长度,返回该区域的地址,它不能初始化所分配的内存空间
,需要用memset,但函数calloc可以,若这部分空间曾经被分配过,可能产生遗留问题。
2、calloc
的函数原型是void* calloc(size_t num,size_t size)
;它实现的功能与malloc类似,参数num为参数个数,size为申请的地址的单位元素长度;它会将所分配的空间中的每一位都初始化为0
;
3、realloc
的函数原型是void* realloc(void* ptr,size_t size)
;它实现的功能是给一个已经分配地址的指针重新分配空间
,参数ptr为原有的空间地址,size是重新申请的地址空间大小,realloc不保持调整后的内存空间和原来的内存空间保持同一内存地址,返回的指针很可能指向新的地址
这几个函数的实现原理:
malloc和calloc是将一块可用的内存连接成一个链表,调用malloc函数时,它沿连接表寻找一个大到足以满足用户请求所需要的内存块,然后将该内存块一分为二(一块与用户申请的大小一样,另一块是剩下的字节),将分配给用户的内存地址传给用户,调用free函数
,将用户释放的内存块连接到空链上,最后空闲链表会被分成很多小内存片段。reallo是如果size小于原本的size,就是缩小内存空间,而相反如果扩大内存空间realloc所做的事是重新申请内存块,将原空间内容拷贝到新空间,释放旧空间,返回新空间。
总结:
- malloc:堆上申请内存空间,随机值;
- cmalloc:堆上申请内存空间并初始化为0;
- relloc:追加开辟内存空间,如果空间不足,将重新开辟一整块空间并将所有数据拷贝后返回新地址。
C++内存管理方式
C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力而且使用起来比较麻烦,因此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理。
void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[3];
delete ptr4;
delete ptr5;
delete[] ptr6;
}
注意:申请和释放单个元素的空间,使用new和delete操作符,申请和释放
连续的空间
,使用new[]和 delete[]
new和delete操作自定义类型
class Test
{
public:
Test()
: _data(0)
{
cout<<"Test():"<<this<<endl;
}
~Test()
{
cout<<"~Test():"<<this<<endl;
}
private:
int _data;
};
void Test2()
{
// 申请单个Test类型的空间
Test* p1 = (Test*)malloc(sizeof(Test));
free(p1);
// 申请10个Test类型的空间
Test* p2 = (Test*)malloc(sizoef(Test) * 10);
free(p2);
void Test2()
{
// 申请单个Test类型的对象
Test* p1 = new Test;
delete p1;
// 申请10个Test类型的对象
Test* p2 = new Test[10];
delete[] p2;
}
注意:在申请自定义类型的空间时,new会调用构造函数,delete会调用析构函数,而malloc与free不会。
new会先申请空间,后调用构造函数
delete会先调用析构函数,后释放资源
建议malloc与free配合使用,new和delete配合使用,否则可能会产生一些问题,例如:内存泄漏,代码崩溃等
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来释放空间
operator new与operator delete函数:
new是先申请空间(operator new)循环使用malloc(count)来申请空间,再调用构造函数,构造对象中的资源
例如:
void *__CRTDECL operator new(size_t count)
{
// try to allocate size bytes
void *p;
while ((p = malloc(count)) == 0)
if (_callnewh(count) == 0)
{
// report no memory
// 如果申请内存失败了,这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}
分析:operator new首先执行malloc申请空间如果malloc申请空间,成功就直接返回,否则执行用户提供的空间不足应对措施,如果用户提供该措施就继续申请,否则就抛异常。
delete是先调用析构函数释放对象中的资源,再释放空间(operator delete)
void operator delete(void *pUserData) {
_CrtMemBlockHeader * pHead;
RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData == NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */
__TRY
/* get a pointer to memory block header */
pHead = pHdr(pUserData);
/* verify block type */
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg(pUserData, pHead->nBlockUse);
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}
operator delete 最终是通过free来释放空间的。
内存泄漏的分类:
堆内存泄漏(Heap leak)
堆内存
指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存,用完后必须通过调用相应的 free或者delete 删掉
。假设程序的设计错误导致这部分内存没有被释放,那么以后这部分空间将无法再被使用,就会产生Heap Leak。
总结:
手动开辟,手动释放,并只能释放一次不能重复释放(浅拷贝与深拷贝)
系统资源泄漏
指程序使用系统分配的资源,比方套接字、文件描述符、管道等没有使用对应的函数释放掉,导致系统资源的浪费,严重可导致系统效能减少,系统执行不稳定。
如何一次在堆上申请4G的内存?
例如:
//如何一次在堆上申请4G的内存?
//在x64的环境下可以运行
int main()
{
void* p = new char[0xfffffffful];
cout << "new:" << p << endl;
return 0;
}
分析:在x64下可以运行(在64位系统下)