C++中新增和删除运算符-yiteyi-C++库

新的和删除运算符也可以像C++中的其他运算符一样重载。New和Delete运算符可以全局重载，也可以针对特定类重载。

null

如果这些运算符是使用类的成员函数重载的，则意味着这些运算符是重载的 只针对那个特定的班级 .
如果重载是在类之外完成的（即，它不是类的成员函数），则只要使用这些运算符（类内或类外），就会调用重载的“new”和“delete”。这是 全局过载 .

重载新运算符的语法：

void* operator new(size_t size);

重载的新运算符接收size_t类型的大小，该类型指定要分配的内存字节数。重载的new的返回类型必须为void*。重载函数返回指向所分配内存块开头的指针。 重载delete运算符的语法：

void operator delete(void*);

函数接收必须删除的void*类型的参数。函数不应返回任何内容。注：重载的new和delete运算符函数都是 静态成员 默认情况下。因此，他们无法访问 this指针 . 重载特定类的new和delete运算符：

CPP

                         // CPP program to demonstrate                       
                         // Overloading new and delete operator                       
                         // for a specific class                       
                         #include<iostream>                       
                         #include<stdlib.h>                       
           
                         using                                     namespace                                     std;                       
                         class                                     student                       
                         {                       
                                                 string name;                       
                                                 int                                     age;                       
                         public                                     :                       
                                                 student()                       
                                                 {                       
                                                 cout<<                                     "Constructor is called"                                     ;                       
                                                 }                       
                                                 student(string name,                                     int                                     age)                       
                                                 {                       
                                                 this                                     ->name = name;                       
                                                 this                                     ->age = age;                       
                                                 }                       
                                                 void                                     display()                       
                                                 {                       
                                                 cout<<                                     "Name:"                                     << name << endl;                       
                                                 cout<<                                     "Age:"                                     << age << endl;                       
                                                 }                       
                                                 void                                     * operator                                     new                                     (                                     size_t                                     size)                       
                                                 {                       
                                                 cout<<                                     "Overloading new operator with size: "                                     << size << endl;                       
                                                 void                                     * p = ::operator                                     new                                     (size);                       
                                                 //void * p = malloc(size); will also work fine                       
                                   
                                                 return                                     p;                       
                                                 }                       
           
                                                 void                                     operator                                     delete                                     (                                     void                                     * p)                       
                                                 {                       
                                                 cout<<                                     "Overloading delete operator "                                     << endl;                       
                                                 free                                     (p);                       
                                                 }                       
                         };                       
           
                         int                                     main()                       
                         {                       
                                                 student * p =                                     new                                     student(                                     "Yash"                                     , 24);                       
           
                                                 p->display();                       
                                                 delete                                     p;                       
                         }                       

输出

Overloading new operator with size: 40Name:YashAge:24Overloading delete operator

注：在上面的新重载函数中，我们通过new操作符分配了动态内存，但它应该是全局new操作符，否则它将进入递归 void*p=new student（）；//这将以递归的形式进行新一次又一次的超载 void*p=：：新学生（）；//这是正确的

new和delete运算符的全局重载

CPP

                         // CPP program to demonstrate                       
                         // Global overloading of                       
                         // new and delete operator                       
                         #include<iostream>                       
                         #include<stdlib.h>                       
           
                         using                                     namespace                                     std;                       
                         void                                     * operator                                     new                                     (                                     size_t                                     size)                       
                         {                       
                                                 cout <<                                     "New operator overloading "                                     << endl;                       
                                                 void                                     * p =                                     malloc                                     (size);                       
                                                 return                                     p;                       
                         }                       
           
                         void                                     operator                                     delete                                     (                                     void                                     * p)                       
                         {                       
                                                 cout <<                                     "Delete operator overloading "                                     << endl;                       
                                                 free                                     (p);                       
                         }                       
           
                         int                                     main()                       
                         {                       
                                                 int                                     n = 5, i;                       
                                                 int                                     * p =                                     new                                     int                                     [3];                       
           
                                                 for                                     (i = 0; i<n; i++)                       
                                                 p[i]= i;                       
           
                                                 cout <<                                     "Array: "                                     ;                       
                                                 for                                     (i = 0; i<n; i++)                       
                                                 cout << p[i] <<                                     " "                                     ;                       
                                   
                                                 cout << endl;                       
           
                                                 delete                                     [] p;                       
                         }                       

输出

New operator overloading Array: 0 1 2 3 4 Delete operator overloading

注：在上面的代码中，在新的重载函数中，我们不能使用 ：：新国际[5] 它将以递归的方式进行。我们只需要使用malloc来分配内存。

为什么要重载新建和删除？

1.重载的新运算符函数可以接受参数；因此，一个类可以有 多重重载新运算符 功能。这为程序员定制对象的内存分配提供了更大的灵活性。例如：

C

                           void                                        *operator                                        new                                        (                                        size_t                                        size,                                        char                                        c)                         
                           {                         
                                                     void                                        *ptr;                         
                                                     ptr =                                        malloc                                        (size);                         
                                                     if                                        (ptr!=NULL)                         
                                                     *ptr = c;                         
                           return                                        ptr;                         
                           }                         
                           main()                         
                           {                         
                                                     char                                        *ch =                                        new                                        (                                        '#'                                        )                                        char                                        ;                         
                           }                         

2.注： 代码不仅会为单个字符分配内存，还会使用 #性格 .

3.重载的new或delete运算符还提供 垃圾收集 对于类的对象。

4.异常处理例程 可以在重载的新运算符函数中添加。

5.有时你想让操作员new和delete做点什么 编译器提供的版本不提供的自定义 。例如，您可以编写一个自定义运算符delete，用零覆盖释放的内存，以提高应用程序数据的安全性。

6.我们可以使用 realloc（）函数 在新功能中动态重新分配内存。

7.重载的新操作符还使程序员能够压缩一些 额外性能 在他们的节目之外。例如，在一个类中，为了加快新节点的分配，将维护一个已删除节点的列表，以便在分配新节点时可以重用它们的内存。在这种情况下，重载的delete操作符将把节点添加到已删除节点的列表中，重载的new操作符将从该列表而不是从堆中分配内存，以加速内存分配。当删除的节点列表为空时，可以使用堆中的内存。

本文由 亚什·辛拉 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章