C语言动态内存开辟
C语言使用malloc/calloc/realloc进行动态内存开辟,malloc/calloc/realloc在堆上开辟一段空间,free将开辟的内存释放掉。
链接
:
(C语言)动态内存开辟
[注意]:
堆上的内存需要用户自己来管理,动态malloc/calloc/realloc的空间,必须free掉,否则会造成内存泄露;栈上空间具有函数作用域,在函数结束后系统自动回收,不用用户管理。栈上,使用_alloc在栈上动态开辟内存,栈上开辟的内存由编译器自动维护,不需要用户显式释放。
C++中动态内存管理
1.new和delete运算符
首先我们先通过一段代码来大概了解一下new,delete,new[],delete[]是怎么使用的。
int* p1 = new int;
//这里是开辟一个单个int型空间(int型为四字节大小)
int* p2 = new int(0);
//开辟一个单个int型空间,并初始化为0
int* p3 = new int[10];
//开辟一段连续空间(10个int型也就是40字节的大小)
delete p1;//释放空间
delete p2;//释放空间
delete p3[];//释放空间
//注意new和delete,new[]和delete[]匹配使用,否则可能出现内存泄漏甚至程序崩溃的问题
2.内存存储方式
* 栈又叫堆栈,主要存放非静态局部变量、函数参数、返回值等,栈是向下增长的。
* 内存映射段是高效的I/O映射方式,用于装载一个共享的动态内存库,做进程间通信。
* 堆用于程序运行时动态内存分配,堆是向上增长的。
* 数据段用于存储全局数据和静态数据。
* 代码段用于存储可执行的代码、只读常量。
3.深入理解C++动态内存管理
new作用:
调用operater new 分配空间,调用构造函数初始化对象
new源码:
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{ // try to allocate size bytes
void *p;
while ((p = malloc(size)) == 0)
if (_callnewh(size) == 0)
{ // report no memory
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}
delete作用:
调用析构函数清理对象,调用operator delete释放空间。
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;
}
new[]作用:
调用operator new分配空间。调用N次构造函数分别初始化每个对象。
new[]源码:
void *__CRTDECL operator new[](size_t count) _THROW1(std::bad_alloc)
{ // try to allocate count bytes for an array
return (operator new(count));
}
delete[]作用:
调用N次析构函数清理对象,调用operator delete释放空间。
delete[]源码:
void operator delete[]( void * p )
{
RTCCALLBACK(_RTC_Free_hook, (p, 0))
operator delete(p);
}
4.malloc/free和new/delete 之间的区别与联系
* 它们都是动态管理内存的入口。
* malloc/free是C/C++标准库的函数,new/delete是C++操作符。
* malloc/free只是动态分配内存空间/释放空间。而new/delete除了分配空间还会调用构造函数和析构函数进行初始化与清理(清理成员)。
* malloc/free需要手动计算类型大小且返回值会void*,new/delete可自己计算类型的大小,返回对应类型的指针。
5.总结
* . operator new/operator delete operator new[]/operator delete[] 和 malloc/free用法一样。
* 他们只负责分配空间/释放空间,不会调用对象构造函数/析构函数来初始化/清理对象。
* 实际operator new和operator delete只是malloc和free的一层封装。
思考问题
1.使用new[]的时候,编译器怎么知道要调用多少次malloc函数?
程序示例:
#include<iostream>
#include<Windows.h>
using namespace std;
class Test
{
public:
Test(int size = 10)
:_size(size)
{
cout<<"Test(int size)" <<endl;
}
~Test()
{
cout<<"~Test()"<<endl;
}
private:
int _size;
};
int main()
{
Test *p = new Test[10];
delete[] p;
system("pause");
return 0;
}
运行调试结果:
【结论】:
从这里我们可以看出在new[]开辟的这段空间前面还另开辟了一段4个字节的空间,记录了new[]要调用malloc函数的次数。
2.假设没有匹配起来使用这两对new/delete,new[]/delete[],什么情况下程序可以正常运行?什么情况会存在内存泄露?什么情况下程序会崩溃?
正常运行:
当创建的类型是内置类型的时候;
内存泄漏:
当写出如下这类代码时会内存泄漏:
#include<iostream>
#include<Windows.h>
using namespace std;
class Test
{
public:
Test(size_t size = 10)
:_size(size)
,_a(0)
{
_a = new int[size];
cout<<"Test(size_t size)" <<endl;
}
~Test()
{
delete[] _a;
cout<<"~Test()"<<endl;
}
private:
int* _a;
size_t _size;
};
int main()
{
Test *p = new Test;
free(p);//free不会调用析构函数,析构函数里才会delete _a
system("pause");
return 0;
}
程序崩溃:
用new[]创建一段连续的空间,如果存在析构函数的话,用free 或是delete来释放这段空间会造成程序崩溃。因为free不会释放p1所指的前四个字节,不会销毁里面定义的空间。delete不会释放p1所指的前四个字节,但会销毁里面定义的空间。