面试过程中,常会问道C++中的new和malloc的区别。
在使用了new运算符之后,编译器实际做了哪些事情呢?
Foo* p = new Foo();
在这个代码中,这里的new实际上是执行如下3个过程:
1 调用operator new分配内存,大小为Foo对象所占用内存大小;
2 调用构造函数生成类对象;
3 返回相应指针。
在C语言中,我们使用malloc/calloc/realloc和free动态开辟和释放内存,而在C++中,我们则经常使用的是new和delete进行动态内存管理。区别在于:
1、malloc/calloc/realloc按字节开辟内存的;new开辟内存时需要指定类型,例如:new int[10]。
2、new不仅可以做内存开辟,还可以做内存的初始化操作。
3、malloc/calloc/realloc开辟内存失败,是通过返回值和nullptr作比较;而new开辟内存失败是通过抛出bad_alloc类型的异常来判断。
4、malloc/calloc/realloc和free,都是c的库函数,new和delete都是运算符。
5、申请和释放单个元素的空间,使用new和delete操作符,申请和释放连续的空间,使用new[]和 delete[]。
6、在申请自定义类型的空间时,new会调用构造函数,delete会调用析构函数,而malloc/calloc/realloc与free不会。
new:指我们在C++里通常用到的运算符,比如A* a = new A; 对于new来说,有new和::new之分,前者位于std。
operator new():指对new的重载形式,它是一个函数,并不是运算符。对于operator new来说,分为全局重载和类重载,全局重载是void* ::operator new(size_t size),在类中重载形式 void* A::operator new(size_t size)。还要注意的是这里的operator new()完成的操作一般只是分配内存,事实上系统默认的全局::operator new(size_t size)也只是调用malloc分配内存,并且返回一个void*指针。而构造函数的调用(如果需要)是在new运算符中完成的
new和operator new之间的关系
A* a = new A;我们知道这里分为两步:1.分配内存,2.调用A()构造对象。事实上,分配内存这一操作就是由operator new(size_t)来完成的,如果类A重载了operator new,那么将调用A::operator new(size_t ),如果没有重载,就调用::operator new(size_t ),全局new操作符由C++默认提供。因此前面的两步也就是:1.调用operator new 2.调用构造函数。
(1)new :不能被重载,其行为总是一致的。它先调用operator new分配内存,然后调用构造函数初始化那段内存。
new 操作符的执行过程:
1. 调用operator new分配内存 ;
2. 调用构造函数生成类对象;
3. 返回相应指针。
(2)operator new:要实现不同的内存分配行为,应该重载operator new,而不是new。
operator new就像operator + 一样,是可以重载的。如果类中没有重载operator new,那么调用的就是全局的::operator new来完成堆的分配。同理,operator new[]、operator delete、operator delete[]也是可以重载的。
C++中new有三种形式:new operator、operator new和placement new。
动态内存管理函数及其调用关系
c++中的动态内存分配和释放方式有很多,主要包括:
malloc与free
new expression与delete expression
array new 与array delete
operator new和operator delete
allocator中的allocate与deallocate
除此之外还有placement new,但需要注意placement new不是用来内存分配和释放的,而是在已分配的内存上构造对象。
他们之间的调用关系如下:
下面我们来具体看下每一种分配和释放方式的使用和原理。
malloc与free
void *p1 = malloc(32); //分配32字节的内存 free(p1);//释放指针p1指向的内存
malloc函数以字节数为参数,返回指向分配的内存的首地址的void指针,malloc在分配失败时会返回NULL;而free函数释放给定指针指向的内存。
事实上,malloc分配的返回给用户使用的内存外面上下会有两个cookie:
这两个cookie用户并不能感受到,但malloc函数实际从操作系统取得的内存实际上是返回给用户的内存加上cookie以及一些对齐填充(请注意,除了最两边的cookie,用户实际得到的内存旁边还有对齐填充字节等其他的overhead,上图以及下面的计算没有考虑这点)。
在VC6中,上下两个cookie记录的是实际分配的内存大小。
以上面的代码举个例子,若上下两个cookie各占4个字节,那么cookie中的值为32+4*2=40或者41(取决于当前内存是否被分配给用户使用)。
正是由于cookie的存在,使得free函数回收内存时,只需要32个字节的首地址,减去4个字节即是真正分配的内存的首地址,而大小也已经知道。free函数不需要大小参数正是由于cookie的存在。
operator new与operator delete
operator new:
(1) 只分配所要求的空间,不调用相关对象的构造函数。当无法满足所要求分配的空间时,则如果有new_handler,则调用new_handler,否则如果没要求不抛出异常(以nothrow参数表达),则执行bad_alloc异常,否则返回0
(2) 可以被重载
(3) 重载时,返回类型必须声明为void*
(4) 重载时,第一个参数类型必须为表达要求分配空间的大小(字节),类型为size_t
(5) 重载时,可以带其它参数
new operator:
(1) 调用operator new分配足够的空间,并调用相关对象的构造函数
(2) 不可以被重载
或许你没有听过 operator new(),只听过 new()。其实 new() 底层是调用 operator new() 来实现的。而operator new() 其实还是调用 malloc()。
void *p6 = ::operator new(32); //分配32字节
::operator delete(p6);
//在这里是这节指定申请的空间大小,调用的函数是下面的这个
operator new失败会抛出异常。
PS:底层调用malloc和free。gnu的实现:
_GLIBCXX_WEAK_DEFINITION void *
operator new (std::size_t sz) _GLIBCXX_THROW (std::bad_alloc)
{
void *p;
/* malloc (0) is unpredictable; avoid it. */
if (__builtin_expect (sz == 0, false))
sz = 1;
while ((p = malloc (sz)) == 0)
{
new_handler handler = std::get_new_handler ();
if (! handler)
_GLIBCXX_THROW_OR_ABORT(bad_alloc());
handler ();
}
return p;
}
_GLIBCXX_WEAK_DEFINITION void
operator delete(void* ptr) noexcept
{
std::free(ptr);
}
new expression与delete expression
int *p2 = new int;
delete p2;
string *p3 = new string("hello");
delete p3;
//这里调用的是
new expression完成两样工作:
申请并分配内存。
调用构造函数。
string *p3 = new string("hello");被编译器替换成下面的工作:
string *p3;
try{
void * tmp_p = operator new(sizeof(string));
p3 = static_cast<string *>(tmp_p);
//string 通过宏被替换为basic_string,string的实际实现是basic_string,这里不是重点。
p3 -> basic_string::basic_string("hello"); //编译器可以这么调用,但我们自己写代码时不能。即我们不能以这种方式通过指针显式调用构造函数。
}catch (std::bad_alloc){
//若分配失败,构造函数不执行
}
我们看到,原来new expression的内存申请和分配是通过调用operator new()来完成的。
delete expression也完成两样工作:
调用析构函数。
释放内存。
delete p3;被编译器替换成下面的工作
p3 -> ~string();//通过指针直接调用析构函数。我们自己写代码时也可以这么做。
operator delete(p3);//释放内存
array new 与array delete
//Complex为自定义类,只需要知道Complex类中没有指针成员。
Complex *pca = new Complex[3];//3次构造函数
delete[] pca;//3次析构函数
string *psa = new string[3];//3次构造函数
delete[] psa;//3次析构函数
array new调用一次内存分配函数(底层源码实现中,其实是调用operator new,调用的时候计算好了大小,大小为3*对象大小 + 一个记录array new的对象个数的字段。因此,有上下两个cookie,还有一个记录分配对象个数的字段。cookie由malloc、free维护,除他们之外不可见;那个长度字段由array new、array delete即new[]、delete[]维护。)和多次构造函数。正因为调用多次构造函数,因此只能调用无参构造函数。
Complex和string的很大不同之处在于,string有指针成员,布局如下图:
array delete调用多次析构函数(调用次数通过delete[]ptr 的ptr再向上某长度,获得前面提到的那个记录new[N]分配的对象个数N的字段),一次内存释放函数(底层源码实现中其实是调用一次operator delete)。
我们来看下,如果本应该使用array delete的地方使用了delete expression会发生什么:
Complex *pca = new Complex[3];//3次构造函数
delete pca;//1次析构函数
string *psa = new string[3];//3次析构函数
delete psa;//1次析构函数
对于Complex,我们使用了array new调用了3次构造函数,却没有使用array delete而使用了delete expression,因此只调用了一次析构函数。那么,会发生内存泄漏吗? 不会。因为Complex的析构函数是无关痛痒的(trivial),因为没有要释放的关联的内存(Complex对象自身所占内存之外没有隐式占用的内存)。
同样,对于string,我们使用了array new调用了3次构造函数,却没有使用array delete而使用了delete expression,因此只调用了一次析构函数。那么,会发生内存泄漏吗? 会。因为string的析构函数不是无关痛痒的(non-trivial),因为要释放关联的内存(我们知道string底层是通过char[]存储的,析构时会释放掉那些实际存储字符的内存)。
PS: 具体的内存布局例子(涉及到cookie、对齐填充padding等等)。
int *p = new int[10];
delete[]p;
//delete p 亦可。int无关痛痒。
VC6中的内存布局如下:
另:
Demo *p = new Demo[3];//Demo为析构函数non-trivial的自定义class
delete[] p;
//delete p; //错误
VC6中的内存布局(注意红框内的3):
allocate与deallocate
#ifdef __GNUC__ //GNUC环境下
void *p7 = allocator<int>().allocate(4); //非static函数,通过实例化匿名对象调用allocate,分配4个int的内存。
allocator<int>().deallocate((int *)p7, 4);
void *p8 = __gnu_cxx::__pool_alloc<int>().allocate(4);
__gnu_cxx::__pool_alloc<int>().deallocate((int *)p8, 4);
#endif
allocator为模板,实例化时需提供模板类型参数,上面的程序中模板类型参数为<int>,allocate的参数为4则allocate函数分配时就分配4个int的内存。释放内存时需要给出指向所要释放的内存位置的指针,以及要释放的内存大小,单位为模板类型参数类型的大小。
__pool_alloc也为模板,除底层调用malloc的时机不同外(__pool_alloc使用内存池降低cookie带来的overhead),使用和上面的allocator相同。
placement new
用法:
char *buf = new char[sizeof(Complex) * 3];
Complex *pc = new(buf) Complex(1, 2);
new(buf + 1) Complex(1, 3);
new(buf + 2) Complex(1, 3);
delete[] buf;
Complex *pc = new(buf) Complex(1, 2);被编译器替换成如下的工作:
Complex *pc;
try{
void *tmp = operator new(sizeof(Complex), buf);//该重载版本并不分配内存。buf指针已经指向内存。
pc = static_cast<Complex*>(tmp);
pc->Complex::Complex(1, 2);//构造函数
}catch(std::bad_alloc){
//若分配失败则不执行构造函数。实际上没有分配,因为之前已经分配完。
}
上面使用的GNU库重载版本的operator new()函数如下:
// Default placement versions of operator new.
_GLIBCXX_NODISCARD inline void* operator new(std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT
{ return __p; }
可以看到确实没有分配内存。
重载内存管理函数
new expression、delete expression都不可重载。
operator new、operator delete可以重载:
重载globaloperator new、operator delete,即::operator new(size_t)与::operator delete(void *)。(一般不会重载全局的该函数,因为影响太广)
重载某个class的operator new、operator delete
若某个类重载了operator new、operator delete,则用new expression实例化该类时,调用的是类的operator new、operator delete,否则,调用globaloperator new、operator delete。
array new、array delete也可以重载。同样分全局的和类所属的。
具体如何重载这些内存管理函数,以及如何使用重载的内存管理函数,将在下一篇文章中分析。
参考资料
[1] 《STL源码剖析》
[2] 《Effective C++》3/e
[3] 《C++ Primer》5/e
[4] 侯捷老师的课程
[5] gcc开源库: https://github.com/gcc-mirror/gcc