C++中新的VS操作符-yiteyi-C++库

当您创建一个新对象时，使用操作符new函数分配内存，然后调用构造函数来初始化内存。在这里，新操作符同时执行分配和初始化，其中作为操作符，new只执行分配。让我们看看这两种方法各自是如何工作的。

null

新关键字

新接线员是一名 操作人员 这表示请求在堆上分配内存。如果有足够的内存可用，new运算符将初始化内存，并将新分配和初始化的内存的地址返回给指针变量。当您使用new关键字（normal new）创建类的对象时。

对象的内存是使用 新接线员 从堆里。
调用该类的构造函数来正确初始化该内存。

                     // CPP program to illustrate                   
                     // use of new keyword                   
                     #include<iostream>                   
                     using                               namespace                               std;                   
                     class                               car                   
                     {                   
                                         string name;                   
                                         int                               num;                   
                             
                                         public                               :                   
                                         car(string a,                               int                               n)                   
                                         {                   
                                         cout <<                               "Constructor called"                               << endl;                   
                                         this                               ->name = a;                   
                                         this                               ->num = n;                   
                                         }                   
                             
                                         void                               enter()                   
                                         {                   
                                         cin>>name;                   
                                         cin>>num;                   
                                         }                   
                             
                                         void                               display()                   
                                         {                   
                                         cout <<                               "Name: "                               << name << endl;                   
                                         cout <<                               "Num: "                               << num << endl;                   
                                         }                   
                     };                   
                             
                     int                               main()                   
                     {                   
                                         // Using new keyword                   
                                         car *p =                               new                               car(                               "Honda"                               , 2017);                   
                                         p->display();                   
                     }                   

输出：

Constructor called
Name: Honda
Num: 2017

新接线员

新接线员是作用它分配原始内存，在概念上有点类似于 malloc（） .

它是覆盖默认堆分配逻辑的机制。
它不会初始化内存，即不调用构造函数。然而，在重载新返回之后，编译器会自动调用构造函数（如果适用）。
也有可能超载操作员新要么是全局的，要么是特定的类

                     // CPP program to illustrate                   
                     // use of operator new                   
                     #include<iostream>                   
                     #include<stdlib.h>                   
                             
                     using                               namespace                               std;                   
                             
                     class                               car                   
                     {                   
                                         string name;                   
                                         int                               num;                   
                             
                                         public                               :                   
                             
                                         car(string a,                               int                               n)                   
                                         {                   
                                         cout <<                               "Constructor called"                               << endl;                   
                                         this                               ->name = a;                   
                                         this                               ->num = n;                   
                                         }                   
                             
                                         void                               display()                   
                                         {                   
                                         cout <<                               "Name: "                               << name << endl;                   
                                         cout <<                               "Num: "                               << num << endl;                   
                                         }                   
                             
                                         void                               *operator                               new                               (                               size_t                               size)                   
                                         {                   
                                         cout <<                               "new operator overloaded"                               << endl;                   
                                         void                               *p =                               malloc                               (size);                   
                                         return                               p;                   
                                         }                   
                             
                                         void                               operator                               delete                               (                               void                               *ptr)                   
                                         {                   
                                         cout <<                               "delete operator overloaded"                               << endl;                   
                                         free                               (ptr);                   
                                         }                   
                     };                   
                             
                     int                               main()                   
                     {                   
                                         car *p =                               new                               car(                               "HYUNDAI"                               , 2012);                   
                                         p->display();                   
                                         delete                               p;                   
                     }                   

输出：

new operator overloaded
Constructor called
Name:HYUNDAI
Num:2012
delete operator overloaded

新操作员vs新操作员

操作员与功能： new是一个运算符，也是一个关键字，而operator new只是一个函数。
新呼叫“新接线员”： “new operator”调用“operator new（）”，就像+operator调用operator+（）
“Operator new”可能会过载： Operator new可以重载，就像允许我们执行定制任务的函数一样。
内存分配： “new expression”调用“operator new”来分配原始内存，然后调用构造函数。

本文由 亚什·辛拉 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

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

THE END

C++头文件