C++入门篇——内存管理
本节介绍C/C++的内存分布,介绍C和C++中动态内存管理,并介绍之间的区别,介绍new和delete关键字的实现原理和定位new表达式。
1 C/C++内存分布
[说明]
- 栈又称为堆栈,通常会将非静态的局部变量,函数参数,返回值等等放入其中,是向下增长的。
- 内存映射段是用于装载一个共享的动态内存库。这里不过多介绍。
- 堆是程序运行时的内存分配,通常区域很大,使用malloc或者new都会在这开辟空间,是向上增长的。
- 数据段,是用来存储全局数据和静态数据的。
- 代码段,是用来存储可执行代码以及只读常量。
2 C语言中动态内存管理方式:malloc/calloc/realloc/free
2.1 malloc
malloc是用来在堆区开辟一块空间供程序使用,如果成功,会返回一个指向这个空间的指针,如果返回失败,则返回空。
语法:void* malloc (size_t size);
头文件:#include <stdlib.h>
使用:
int* p1 = (int*) malloc(sizeof(int));
2.2 calloc
calloc与malloc相似,并且在开辟空间后,自动为空间内的元素初始化为0。
语法:void* calloc (size_t num, size_t 大小);
头文件:#include <stdlib.h>
使用:
int* p2 = (int*)calloc(4, sizeof (int));
2.3 realloc
realloc是改变已有的堆空间大小,并返回指向这块新空间的指针。
语法:void* realloc (void* ptr, size_t size);
头文件:#include <stdlib.h>
使用:
int* p3 = (int*)realloc(p2, sizeof(int)*10);
2.4 free
free是用来释放已有的堆空间,还给操作系统。
语法:void free (void* ptr);
头文件:#include <stdlib.h>
使用:
free(p1);
free(p3);
3 C++内存管理方式
3.1 new/delete 操作内置类型
new/delete是C++的关键字,其实本质上也是进行堆内存的开辟和释放。下面介绍它的用法:
语法:new 类型 / new 类型[数组大小]
delete 指向堆内存的指针 / delete[] 指向堆内存指针的数组
使用:
int main()
{
// 动态申请一个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 可以针对内置类型进行初始化,需要在类型后加一个括号,并放入初始化的值。这里用new创建的数组,必须要用对应delete[]
的方式进行释放,否则可能会出错。
3.2 new/delete 操作自定义类型
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A(1);
free(p1);
delete p2;
// 内置类型是几乎是一样的
int* p3 = (int*)malloc(sizeof(int)); // C
int* p4 = new int;
free(p3);
delete p4;
A* p5 = (A*)malloc(sizeof(A) * 10);
A* p6 = new A[10];
free(p5);
delete[] p6;
return 0;
}
针对自定义类型,new和delete都会调用对应类型的构造函数和析构函数,这和malloc和free的区别在于,C语言的malloc和free不会去调用自定义类型的构造函数和析构函数。
4 operator new与operator delete函数
new和delete是用户进行内存申请和释放的关键字,而operator new 和operator delete是系统提供的全局函数,其实,new和delete底层就是去调用这两个全局函数,那么,我们看一下这两个函数的源码是如何实现的。
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
// 如果申请内存失败了,这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}
/*
operator delete: 该函数最终是通过free来释放空间的
*/
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 new
本质上还是去调用C语言的malloc
函数,并且对于malloc函数的返回值进行了处理, 它是通过抛异常的方式,如果malloc内存不够了,会再去看看还有没有可以在用的空间,如果没有,就会抛出异常。
虽然,我们在operator delete没有看到free函数,但其实free函数也是对于_free_dbg
这个函数的封装,_free_dbg
这个函数会对于我们传进去的指针进行内存释放。并且operator delete 还做了一系列处理。
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
那么,针对于operator new 和operator delete这两个函数是可以进行重载的,也就是说,我们在编写一个自定义类的时候,可以实现一个专属的new和delete的版本。
class A
{
public:
A(int a) : _a(a) {}
void *operator new(size_t size)
{
void* p = ::operator new(size);
cout << "operator new(size_t size)" << endl;
return p;
}
void operator delete(void* p)
{
cout << "operator delete(void* p)" << endl;
::operator delete(p);
}
private:
int _a;
};
5 new和delete的实现原理
5.1 内置类型
如果申请的是内置类型的空间,new和malloc,delete和free类似,不同的地方在于,new申请的失败的时候是抛异常,而malloc是返回NULL,并且new可以进行初始化,而C语言虽然有calloc,但是只能初始化为0。
5.2 自定义类型
- new的原理
- 调用operator new函数申请空间
- 在申请的空间上执行构造函数
- delete的原理
- 在空间上执行析构函数,完成对象中资源的清理。
- 调用operator delete来释放对象的空间
- new T[N]的原理
- 调用operator new[]函数,来完成对N个对象空间的申请
- 并且执行N次的构造函数
- delete[]的原理
- 在释放对象空间,执行N次析构函数,完成N个对象资源清理。
- 调用operator delete[]释放空间。
6 定位new表达式(placement-new)
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
我们有的时候,在进行new创建对象后,发现想要对已有的这个对象进行初始化,就可以使用这个表达式。
语法:new(已分配的堆空间的指针)类型(初始化值)
int main()
{
int* p = new int;
cout << *p << endl; // 随机值
new(p)int(3);
cout << *p << endl; // 3
}