malloc/free与c++中new/delete、operator new/operator delete与placement new的区别？

我不是女神ヾ 2022-05-31 22:54 177阅读 0赞

# malloc/free与new/delete #

## 相同点 ##

> 二者都可以从堆中申请和分配动态内存，并且二者都必须成对匹配使用。new/delete和malloc/free必须配对使用，才可以正确完成内存的的申请和释放功能。

## 不同点 ##

malloc/free是标准库里面的函数，只能用于分配内部数据类型（int char等等）。

void * malloc(size_t size);//malloc原型
    //malloc只负责从堆中取出对应的字节数然后返回其地址（类型是void *），一般需要通过强制转换地址类型，用来告诉编译器，分配的字节应该如何组织（数据类型都是这种作用，告诉编译器字节应该如何组织）。
    int *a = malloc(sizeof(int) * 4);//分配a[4]数组。告诉类型是int*,那么编译器就会每次取4字节。

new/delete是c++编译器自带的操作符（意味着运算符出现编译器会自动处理），并且new内置了sizeof、类型转换和类型安全检查功能，对于非内部数据类的对象而言，用malloc/free无法满足动态管理对象的要求。因为对象在创建的同时需要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。因此C++需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。下面是一个简单的示例：

class Obj  
    {  
    public:  
        Obj( )   
        { cout  <<  "Initialization"  <<  endl; }  
        ~ Obj( )  
        { cout  <<  "Destroy" <<  endl; }  
        void Initialize( )  
        { cout  <<  "Initialization"  <<  endl; }  
        void  Destroy( )  
        { cout  <<  "Destroy"  <<  endl; }  
    }obj;  
    
    void  UseMallocFree( )  
    {  
        Obj   * a  =  (Obj  *) malloc( sizeof ( obj ) );      // allocate memory 
        a -> Initialize();                                    // initialization 
        // … 
        a -> Destroy();                                        // deconstruction 
        free(a);                                               // release memory 
    }  
    
    void  UseNewDelete( void )  
    {  
        Obj   * a  =   new  Obj;                                             
        // … 
        delete a;   
    }

类Obj的函数Initialize实现了构造函数的功能，函数Destroy实现了析构函数的功能。函数UseMallocFree中，由于malloc/free不能执行构造函数与析构函数，必须调用成员函数Initialize和Destroy来完成“构造”与“析构”。所以我们不要用malloc/free来完成动态对象的内存管理，应该用new/delete。由于内部数据类型的“对象”没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。

## 联系 ##

既然new/delete的功能完全覆盖了malloc/free，为什么C++还保留malloc/free呢？因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。如果用free释放“new创建的动态对象”，那么该对象因无法执行析构函数而可能导致程序出错。如果用delete释放“malloc申请的动态内存”，理论上讲程序不会出错，但是该程序的可读性很差。所以new/delete、malloc/free必须配对使用。  
参考：[http://blog.csdn.net/hackbuteer1/article/details/6789164][http_blog.csdn.net_hackbuteer1_article_details_6789164]

# operator new/operator delete与placement new #

new执行两步操作首先调用operator new分配对应的内存，然后调用对象的构造函数初始化内存。用户不可以改变new操作的步骤，但是可以修改内存分配的方，也就是可以重载operator new。  
前面的new/delete是编译器自带操作符，而operator new/operator delete是对应的函数，系统默认实现了此函数并且用户可以重载。  
1、operator new

> （1）只分配所要求的空间，不调用相关对象的构造函数。当无法满足所要求分配的空间时，则 如果有new\_handler，则调用new\_handler，否则如果没要求不抛出异常（以nothrow参数表达），则执行bad\_alloc异常，否则返回0。  
> （2）可以被重载，每一个类可以实现自己的operator new给new运算符使用。  
> （3）重载时，返回类型必须声明为void\*。  
> （4）重载时，第一个参数类型必须为表达要求分配空间的大小（字节被new调用），类型为size\_t。  
> （5）重载时，可以带其它参数（new里面参数，传入operator new大小之后的参数列表）。

2、new操作符

> （1）调用operator new分配足够的空间，并调用相关对象的构造函数。  
> （2）不可以被重载。

#ifndef TESTNEW_H
    #define TESTNEW_H
    #include<iostream>
    #include<string>
    using namespace std;
    
    class TestNew
    {
    public:
        TestNew():i(9){
       //默认构造函数
            cout<< "Construct of TestNew" << endl;
        }
        ~TestNew(){
       //默认析构函数
            cout<< "Destructor of TestNew" << endl;
        }
        void *operator new(size_t size , string str){
       //重载，并传递一个自定义参数
            cout << str << endl;
            cout << "operator new size " << size << endl;
            return ::operator new(size);//调用系统默认的operator new
        }
        void operator delete(void *ptr){
       //重载，并传递一个自定义参数
            cout << "operator delete" << endl;
            return ::operator delete(ptr);//调用系统默认的operator new
        }
        int i;
    };
    #endif // TESTNEW_H
    #include"testnew.h"
    int main(void)
    {
        TestNew *ptr = new("my test operator new") TestNew;
        //new先调用operator new分配内存，然后调用构造函数。
    
        delete ptr;
        //delete先调用调用析构函数，然后调用operator delete释放内存。
        return 0;
    }

![这里写图片描述][SouthEast]

> new/delete 操作符的行为是不可以改变。而operator new与operator delete和C语言中的malloc与free对应，只负责分配及释放空间。但使用operator new分配的空间必须使用operator delete来释放，而不能使用free，因为它们对内存使用的登记方式不同。反过来亦是一样。可以重载operator new和operator delete以实现对内存管理的不同要求，但你不能重载new operator或delete operator以改变它们的行为。

3、placement new

> 允许程序员将对象创建在已经被分配好的内存中，这种形式的new表达式被称为定位new表达式。表达式为  
> `new (place_address) type -specifier`，  
> `place_address`必须是一个已经分配好内存空间的指针，然后包含new头文件，通过上述形式在已经分配的内存空间上面创建对应的对象，达到调用构造函数的效果。

#include<new>
    class FOO{
    public:
        int val(){
            return _val;
        }
        FOO():_val(0){}
    private:
        int _val;
    };
    int main(void)
    {
        char *buf = new char[sizeof(FOO)];//通过new分配空间，此时相当于malloc
        FOO *ptr = new(buf) FOO;//在分配好空间构造FOO，也就调用默认构造函数
        if(ptr->val() == 0)
            cout << "new expression worked" << endl;
        ptr->~FOO();//调用析构函数
        delete[] buf;//不存在定位new的delete，因为不分配内存，只需要删除先前分配的缓冲即可，foo自行消失。
        return 0;
     }

> 不存在与定位new表达式相匹配的delete表达式。其实我们并不需要这样的delete表达式，因为定位new表达式并不分配内存。因此删除的不是指针ptr指向的内存，而是buf指向的内存。当程序结尾处不再需要字符缓冲时，buf指向的内存被删除。 当字符缓冲被删除时，它所包含的任何对象的生命期也就都结束了，那么ptr不再指向一个有效的FOO型的对象。

4、Placement new使用步骤

> 1、缓存提前分配，例如通过上述的`char *buf = new char[sizeof(FOO)];`。  
> 2、在已经分配的缓存上调用placement new来构造一个对象。`FOO *ptr = new(buf) FOO;`  
> 3、使用分配的对象。`ptr->val()`  
> 4、对象的析构。一旦你使用完这个对象，你必须调用它的析构函数来毁灭它。`ptr->~FOO();`  
> 5、释放对应的内存，可以反复利用缓存并给它分配一个新的对象（重复步骤2，3，4），如果不打算再次使用这个缓存，你可以释放它，`delete[] buf;`  
> 在STL内存分配中大量使用了这种技巧。因为STL中内存的分配和对象的构造是分开进行的，所以肯定需要使用这种先分配再构造的技巧。

5、new 、operator new 和 placement new 区别

> （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\[\]也是可以重载的。  
> （3）placement new：只是operator new重载的一个版本。它并不分配内存，只是返回指向已经分配好的某段内存的一个指针。因此不能删除它，但需要调用对象的析构函数。  
> 如果你想在已经分配的内存中创建一个对象，使用new时行不通的。也就是说placement new允许你在一个已经分配好的内存中（栈或者堆中）构造一个新的对象。原型中void\* p实际上就是指向一个已经分配好的内存缓冲区的的首地址。

参考：[https://www.cnblogs.com/luxiaoxun/archive/2012/08/10/2631812.html][https_www.cnblogs.com_luxiaoxun_archive_2012_08_10_2631812.html]

[http_blog.csdn.net_hackbuteer1_article_details_6789164]: http://blog.csdn.net/hackbuteer1/article/details/6789164
[SouthEast]: /images/20220601/57a7f057b92e482c9e26732cadbd968f.png
[https_www.cnblogs.com_luxiaoxun_archive_2012_08_10_2631812.html]: https://www.cnblogs.com/luxiaoxun/archive/2012/08/10/2631812.html