new和malloc两个函数详细实现与原理分析

Posted 2023-04-03 ST小智

1.申请的内存所在位置

new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。

那么自由存储区是否能够是堆（问题等价于new是否能在堆上动态分配内存），这取决于operator new 的实现细节。自由存储区不仅可以是堆，还可以是静态存储区，这都看operator new在哪里为对象分配内存。

特别的，new甚至可以不为对象分配内存！定位new的功能可以办到这一点：

new (place_address) type

place_address为一个指针，代表一块内存的地址。当使用上面这种仅以一个地址调用new操作符时，new操作符调用特殊的operator new，也就是下面这个版本：

void * operator new (size_t,void *) //不允许重定义这个版本的operator new

这个operator new不分配任何的内存，它只是简单地返回指针实参，然后右new表达式负责在place_address指定的地址进行对象的初始化工作。

2.返回类型安全性

new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。
类型安全很大程度上可以等价于内存安全，类型安全的代码不会试图方法自己没被授权的内存区域。关于C++的类型安全性可说的又有很多了。

3.内存分配失败时的返回值

new内存分配失败时，会抛出bac_alloc异常，它不会返回NULL；malloc分配内存失败时返回NULL。
在使用C语言时，我们习惯在malloc分配内存后判断分配是否成功：

int *a  = (int *)malloc ( sizeof (int ));
if(NULL == a)

    ...

else 

    ...

从C语言走入C++阵营的新手可能会把这个习惯带入C++：

int * a = new int();
if(NULL == a)

    ...

else
   
    ...

实际上这样做一点意义也没有，因为new根本不会返回NULL，而且程序能够执行到if语句已经说明内存分配成功了，如果失败早就抛异常了。正确的做法应该是使用异常机制：

try

    int *a = new int();

catch (bad_alloc)

    ...

如果你想顺便了解下异常基础，可以看
http://www.cnblogs.com/QG-whz/p/5136883.htmlC++ 异常机制分析。

4.是否需要指定内存大小

使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算，而malloc则需要显式地指出所需内存的尺寸。

class A...
A * ptr = new A;
A * ptr = (A *)malloc(sizeof(A)); //需要显式指定所需内存大小sizeof(A);

当然了，我这里使用malloc来为我们自定义类型分配内存是不怎么合适的，请看下一条。

5.是否调用构造函数/析构函数

使用new操作符来分配对象内存时会经历三个步骤：

• 第一步：调用operator new 函数（对于数组是operator new[]）分配一块足够大的，原始的，未命名的内存空间以便存储特定类型的对象。

• 第二步：编译器运行相应的构造函数以构造对象，并为其传入初值。

• 第三部：对象构造完成后，返回一个指向该对象的指针。

使用delete操作符来释放对象内存时会经历两个步骤：

• 第一步：调用对象的析构函数。

• 第二步：编译器调用operator delete(或operator delete[])函数释放内存空间。

总之来说，new/delete会调用对象的构造函数/析构函数以完成对象的构造/析构。而malloc则不会。如果你不嫌啰嗦可以看下我的例子：

class A

public:
    A() :a(1), b(1.11)
private:
    int a;
    double b;
;
int main()

    A * ptr = (A*)malloc(sizeof(A));
    return 0;

在return处设置断点，观看ptr所指内存的内容：

可以看出A的默认构造函数并没有被调用，因为数据成员a,b的值并没有得到初始化，这也是上面我为什么说使用malloc/free来处理C++的自定义类型不合适，其实不止自定义类型，标准库中凡是需要构造/析构的类型通通不合适。

而使用new来分配对象时：

int main()

    A * ptr = new A;

查看程序生成的汇编代码可以发现，A的默认构造函数被调用了：

6.对数组的处理

C++提供了new[]与delete[]来专门处理数组类型:

    A * ptr = new A[10];//分配10个A对象

使用new[]分配的内存必须使用delete[]进行释放：

    delete [] ptr;

new对数组的支持体现在它会分别调用构造函数函数初始化每一个数组元素，释放对象时为每个对象调用析构函数。注意delete[]要与new[]配套使用，不然会找出数组对象部分释放的现象，造成内存泄漏。

至于malloc，它并知道你在这块内存上要放的数组还是啥别的东西，反正它就给你一块原始的内存，在给你个内存的地址就完事。所以如果要动态分配一个数组的内存，还需要我们手动自定数组的大小：

int * ptr = (int *) malloc( sizeof(int)* 10 );//分配一个10个int元素的数组

7.new与malloc是否可以相互调用

operator new /operator delete的实现可以基于malloc，而malloc的实现不可以去调用new。下面是编写operator new /operator delete 的一种简单方式，其他版本也与之类似：

void * operator new (sieze_t size)

    if(void * mem = malloc(size)
        return mem;
    else
        throw bad_alloc();

void operator delete(void *mem) noexcept

    free(mem);

8.是否可以被重载

opeartor new /operator delete可以被重载。标准库是定义了operator new函数和operator delete函数的8个重载版本：

//这些版本可能抛出异常
void * operator new(size_t);
void * operator new[](size_t);
void * operator delete (void * )noexcept;
void * operator delete[](void *0）noexcept;
//这些版本承诺不抛出异常
void * operator new(size_t ,nothrow_t&) noexcept;
void * operator new[](size_t, nothrow_t& );
void * operator delete (void *,nothrow_t& )noexcept;
void * operator delete[](void *0,nothrow_t& ）noexcept;

我们可以自定义上面函数版本中的任意一个，前提是自定义版本必须位于全局作用域或者类作用域中。太细节的东西不在这里讲述，总之，我们知道我们有足够的自由去重载operator new /operator delete ,以决定我们的new与delete如何为对象分配内存，如何回收对象。

而malloc/free并不允许重载。

9. 能够直观地重新分配内存

使用malloc分配的内存后，如果在使用过程中发现内存不足，可以使用realloc函数进行内存重新分配实现内存的扩充。realloc先判断当前的指针所指内存是否有足够的连续空间，如果有，原地扩大可分配的内存地址，并且返回原来的地址指针；如果空间不够，先按照新指定的大小分配空间，将原有数据从头到尾拷贝到新分配的内存区域，而后释放原来的内存区域。

new没有这样直观的配套设施来扩充内存。

10. 客户处理内存分配不足

在operator new抛出异常以反映一个未获得满足的需求之前，它会先调用一个用户指定的错误处理函数，这就是new-handler。new_handler是一个指针类型：

namespace std

    typedef void (*new_handler)();

指向了一个没有参数没有返回值的函数,即为错误处理函数。为了指定错误处理函数，客户需要调用set_new_handler，这是一个声明于的一个标准库函数:

namespace std

    new_handler set_new_handler(new_handler p ) throw();

set_new_handler的参数为new_handler指针，指向了operator new 无法分配足够内存时该调用的函数。其返回值也是个指针，指向set_new_handler被调用前正在执行（但马上就要发生替换）的那个new_handler函数。

对于malloc，客户并不能够去编程决定内存不足以分配时要干什么事，只能看着malloc返回NULL。

回到顶部

总结

将上面所述的10点差别整理成表格：

特征	new/delete	malloc/free
分配内存的位置	自由存储区	堆
内存分配成功的返回值	完整类型指针	void*
内存分配失败的返回值	默认抛出异常	返回NULL
分配内存的大小	由编译器根据类型计算得出	必须显式指定字节数
处理数组	有处理数组的new版本new[]	需要用户计算数组的大小后进行内存分配
已分配内存的扩充	无法直观地处理	使用realloc简单完成
是否相互调用	可以，看具体的operator new/delete实现	不可调用new
分配内存时内存不足	客户能够指定处理函数或重新制定分配器	无法通过用户代码进行处理
函数重载	允许	不允许
构造函数与析构函数	调用	不调用

malloc给你的就好像一块原始的土地，你要种什么需要自己在土地上来播种

而new帮你划好了田地的分块（数组），帮你播了种（构造函数），还提供其他的设施给你使用:

当然，malloc并不是说比不上new，它们各自有适用的地方。

C++—new/delete/malloc/free详解

主要内容：

1．  C语言中的函数malloc和free

2．  C++中的运算符new和delete

3．  new/delete与malloc/free之间的联系和区别

4．  C/C++程序的内存分配介绍

详细介绍：

　　C语言的函数malloc和free

 (1) 函数malloc和free在头文件<stdlib.h>中的原型及参数

void * malloc(size_t size)

动态配置内存，大小有size决定，返回值成功时为任意类型指针，失败时为NULL。  

    void  free(void *ptr)

释放动态申请的内存空间，调用free( )后ptr所指向的内存空间被收回，如果ptr指向未知地方或者指向的空间已被收回，则会发生不可预知的错误，如果ptr为NULL，free不会有任何作用。

(2) C语言中典型用法

 T *p = ( T* )malloc( sizeof(T) * n)  //T为任意数据类型
       if(NULL= =p)
{
       printf(“malloc fail!\n”);
       ……//相关资源收回的处理
       exit(-1);
}
… …//此过程不能改变指针p的指向
free(p);

注意：malloc后通常要对返回值进行判断，避免发生不必要的错误。

(3) 内存说明

malloc函数动态申请的内存空间是在堆里(而一般局部变量存于栈里)，并且该段内存不会被初始化，与全局变量不一样，如果不采用手动free()加以释放，则该段内存一直存在，直到程序退出才被系统，所以为了合理使用内存，在不适用该段内存时，应该调用free()。另外，如果在一个函数里面使用过malloc，最好要配对使用free，否则容易造成内存泄露。

　　 C++中的运算符new和delete

new和delete是C++中的运算符，不是库函数，不需要库的支持，同时，他们是封装好的重载运算符，并且可以再次进行重载。

//new运算的例子
new int  //开辟一个存放整数的存储空间，返回一个指向该存储空间的地址
new int(100)  //同上，并指定该整数的初值为100
new char[100] //开辟一个存放字符数组（100个元素）的空间，返回首地址
new int[4][5]//开辟一个存放二维数组的空间，返回首元素的地址
float *p=new float(3.14157) //开辟一个存放单精度的空间，并指定该数的初值为3.14157，
                              将返回的该空间的地址赋给指针变量p

注意：用new分配数组空间不能指定初值，若无法正常分配，则new会返回一个空指针NULL,用户可以根据此判断是否分配成功。

delete运算符使用的一般格式：

delete  指针变量   or    delete  [ ] 指针变量（对数组）

（1）         new是动态分配内存的运算符，自动计算需要分配的空间，在C++中，它属于重载运算符，可以对多种数据类型形式进行分配内存空间，比如int型、char型、结构体型和类等的动态申请的内存分配，分配类的内存空间时，同时调用类的构造函数，对内存空间进行初始化，即完成类的初始化工作。

（2）         delete是撤销动态申请的内存运算符。delete与new通常配对使用，与new的功能相反，可以对多种数据类型形式的内存进行撤销，包括类，撤销类的内存空间时，它要调用其析构函数，完成相应的清理工作，收回相应的内存资源。

（3）         典型用法

int *p = new int；                    delete p；

char *p = new char；                  delete p；

类的类型 *p = new 类的类型； delete p；

//注意，指针p存于栈中，p所指向的内存空间却是在堆中。

                            Obj * p = new Obj[100];                     delete [ ]p;

//注意，new申请数组，delete删除的形式需要加括号“[ ]”，表示对数组空间的操作，总之，申请形式如何，释放的形式就如何。

（4）         内存说明。new申请的内存也是存于堆中，所以在不需要使用时，需要delete手动收回。

　　  new/delete与malloc/free之间的联系和区别

(1)          malloc/free和new/delete的联系

a）          存储方式相同。malloc和new动态申请的内存都位于堆中。申请的内存都不能自动被操作系统收回，都需要配套的free和delete来释放。

b）          除了带有构造函数和析构函数的类等数据类型以外，对于一般数据类型，如int、char等等，两组动态申请的方式可以通用，作用效果一样，只是形式不一样。

c）          内存泄漏对于malloc或者new都可以检查出来的，区别在于new可以指明是那个文件的那一行，而malloc没有这些信息。

d）          两组都需要配对使用，malloc配free，new配delete，注意，这不仅仅是习惯问题，如果不配对使用，容易造成内存泄露。同时，在C++中，两组之间不能混着用，虽说有时能编译过，但容易存在较大的隐患。

(2)          malloc/free和new/delete的区别

a）          malloc和free返回void类型指针，new和delete直接带具体类型的指针。

b）          malloc和free属于C语言中的函数，需要库的支持，而new/delete是C++中的运算符，况且可以重载，所以new/delete的执行效率高些。C++中为了兼用C语法，所以保留malloc和free的使用，但建议尽量使用new和delete。

c）          在C++中， new是类型安全的，而malloc不是。例如：

　int* p = new char[10];                    // 编译时指出错误

  delete [ ]p;                                     //对数组需要加中括号“[ ]”

　int* p = malloc(sizeof(char )*10);    // 编译时无法指出错误

   free (p);                                       //只需要所释放内存的头指针

d）          使用new动态申请类对象的内存空间时，类对象的构建要调用构造函数，相当于对内存空间进行了初始化。而malloc动态申请的类对象的内存空间时，不会初始化，也就是说申请的内存空间无法使用，因为类的初始化是由构造函数完成的。delete和free的意义分别于new和malloc相反。

e）          不能用malloc和free来完成类对象的动态创建和删除。

　　  C/C++程序的内存分配介绍

该部分参考于http://blog.csdn.net/sparkliang/archive/2008/12/30/3650324.aspx

（1）栈内存分配运算内置于处理器的指令集中，一般使用寄存器来存取，效率很高，但是分配的内存容量有限。 一般局部变量和函数参数的暂时存放位置。

（2） 堆内存，亦称动态内存。如malloc和new申请的内存空间。动态内存的生存期由程序员自己决定，使用非常灵活。 

（3）全局代码区：从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。 

（4）常量区：文字常量分配在文字常量区，程序结束后由系统释放。 

（5）代码区：存放整个程序的代码，因为存储是数据和代码分开存储的。