new 运算符 (C++)

尝试分配和初始化指定类型或占位符类型的对象或对象数组，并返回指向对象（或指向数组初始对象）的适当类型化的非零指针。

语法

new-expression：
  ::_optnewnew-placement_optnew-type-idnew-initializer_opt
  ::_optnewnew-placement_opt(type-id)new-initializer_opt

new-placement：
  ( expression-list )

new-type-id：
  type-specifier-seqnew-declarator_opt

new-declarator：
  ptr-operatornew-declarator_opt
  noptr-new-declarator

noptr-new-declarator：
  [expression]attribute-specifier-seq_opt
  noptr-new-declarator[constant-expression]attribute-specifier-seq_opt

new-initializer：
  (expression-list_opt)
  braced-init-list

备注

如果未成功，new 将返回零或引发异常。 有关详细信息，请参阅 new 和 delete 运算符。 可以通过编写自定义异常处理例程并调用 _set_new_handler 运行时库函数（使用函数名作为其参数）来更改此默认行为。

要了解如何使用 C++/CLI 和 C++/CX 在托管堆上创建对象，请参阅 gcnew。

注意

Microsoft C++ 组件扩展 (C++/CX) 支持 new 关键字，可用于添加 vtable 槽条目。 有关详细信息，请参阅 new（vtable 中的新槽）

使用 new 为 C++ 类对象分配内存时，将在分配内存后调用对象的构造函数。

使用 delete 运算符解除由 new 运算符分配的内存。 使用 delete[] 运算符删除由 new 运算符分配的数组。

以下示例先分配然后释放一个二维字符数组，数组的大小为 dim x 10。 分配多维数组时，除第一个维度外的所有维度都必须是计算结果为正值的常数表达式。 最左侧的数组维度可以是任何计算结果为正值的表达式。 使用 new 运算符分配数组时，第一个维度可以为零；new 运算符返回一个唯一指针。

char (*pchar)[10] = new char[dim][10];
delete [] pchar;

type-id 不能包含 const、volatile、类声明或枚举声明。 以下表达式格式不正确：

volatile char *vch = new volatile char[20];

new 运算符不分配引用类型，因为它们不是对象。

new 运算符不能用于分配函数，但可用于分配指向函数的指针。 下面的示例为返回整数的函数分配然后释放一个包含 7 个指针的数组。

int (**p) () = new (int (*[7]) ());
delete p;

如果使用不带任何额外参数的运算符 new，并使用 /GX、/EHa 或 /EHs 选项进行编译，编译器会在构造函数引发异常时生成调用运算符 delete 的代码。

以下列表描述了 new 的语法元素：

new-placement
如果重载 new，就会提供一种传递额外参数的方法。

type-id
指定要分配的类型；它可以是内置类型，也可以是用户定义类型。 如果类型规范非常复杂，则可用括号将其括起来以强制实施绑定顺序。 类型可以是一个占位符（auto），其类型由编译器决定。

new-initializer
为初始化对象提供值。 不能为数组指定初始值设定项。 仅当类具有默认构造函数时，new 运算符才会创建对象数组。

noptr-new-declarator
指定数组边界。 分配多维数组时，除第一个维度外的所有维度都必须是常数表达式，其计算结果为可转换为 std::size_t 的正值。 最左侧的数组维度可以是任何计算结果为正值的表达式。 attribute-specifier-seq 适用于关联的数组类型。

示例：分配和释放字符数组

下面的代码示例分配类 CName 的一个字符数组和一个对象，然后释放它们。

// expre_new_Operator.cpp
// compile with: /EHsc
#include <string.h>

class CName {
public:
   enum {
      sizeOfBuffer = 256
   };

   char m_szFirst[sizeOfBuffer];
   char m_szLast[sizeOfBuffer];

public:
   void SetName(char* pszFirst, char* pszLast) {
     strcpy_s(m_szFirst, sizeOfBuffer, pszFirst);
     strcpy_s(m_szLast, sizeOfBuffer, pszLast);
   }

};

int main() {
   // Allocate memory for the array
   char* pCharArray = new char[CName::sizeOfBuffer];
   strcpy_s(pCharArray, CName::sizeOfBuffer, "Array of characters");

   // Deallocate memory for the array
   delete [] pCharArray;
   pCharArray = NULL;

   // Allocate memory for the object
   CName* pName = new CName;
   pName->SetName("Firstname", "Lastname");

   // Deallocate memory for the object
   delete pName;
   pName = NULL;
}

示例：new 运算符

如果使用 new 运算符的放置形式（参数多于大小的形式），若构造函数引发异常，编译器将不支持 delete 运算符的放置形式。 例如：

// expre_new_Operator2.cpp
// C2660 expected
class A {
public:
   A(int) { throw "Fail!"; }
};
void F(void) {
   try {
      // heap memory pointed to by pa1 will be deallocated
      // by calling ::operator delete(void*).
      A* pa1 = new A(10);
   } catch (...) {
   }
   try {
      // This will call ::operator new(size_t, char*, int).
      // When A::A(int) does a throw, we should call
      // ::operator delete(void*, char*, int) to deallocate
      // the memory pointed to by pa2.  Since
      // ::operator delete(void*, char*, int) has not been implemented,
      // memory will be leaked when the deallocation can't occur.

      A* pa2 = new(__FILE__, __LINE__) A(20);
   } catch (...) {
   }
}

int main() {
   A a;
}

对使用 new 分配的对象进行初始化

new 运算符的语法中包含一个可选的 new-initializer 字段。 此字段支持使用用户定义的构造函数进行初始化的新对象。 有关如何完成初始化的详细信息，请参阅初始值设定项。 以下示例说明了如何将初始化表达式与 new 运算符配合使用：

// expre_Initializing_Objects_Allocated_with_new.cpp
class Acct
{
public:
    // Define default constructor and a constructor that accepts
    //  an initial balance.
    Acct() { balance = 0.0; }
    Acct( double init_balance ) { balance = init_balance; }
private:
    double balance;
};

int main()
{
    Acct *CheckingAcct = new Acct;
    Acct *SavingsAcct = new Acct ( 34.98 );
    double *HowMuch = new double { 43.0 };
    // ...
}

在此示例中，使用 new 运算符分配对象 CheckingAcct，但未指定默认初始化。 因此，将调用类的默认构造函数 Acct()。 然后，以相同的方式分配对象 SavingsAcct，只不过将它显式初始化为 34.98。 由于 34.98 是 double 类型，所以会调用接受此类型参数的构造函数来处理初始化。 最后，将非类类型 HowMuch 初始化为 43.0。

如果对象属于类类型并且此类具有构造函数（如上例所示），只有满足以下条件之一时，new 运算符才能将对象初始化：

• 初始值设定项中提供的参数与构造函数的参数相匹配。

• 该类有一个默认构造函数（可在没有参数的情况下调用的构造函数）。

使用 new 运算符分配数组时，无法对每个元素执行显式初始化；仅调用默认构造函数（如果存在）。 有关详细信息，请参阅默认参数。

如果内存分配失败（operator new 返回值为 0），不会进行初始化。 此行为可防止尝试初始化不存在的数据。

与函数调用一样，未定义初始化表达式的求值顺序。 此外，不应指望在执行内存分配前对这些表达式进行完整计算。 如果内存分配失败且 new 运算符返回零，可能无法完整计算初始值设定项中的某些表达式。

使用 new 分配的对象的生存期

使用 new 运算符分配的对象在退出定义它们的范围时不会被销毁。 因为 new 运算符返回一个指向其分配的对象的指针，所以程序必须定义一个具有合适范围的指针来访问和删除这些对象。 例如：

// expre_Lifetime_of_Objects_Allocated_with_new.cpp
// C2541 expected
int main()
{
    // Use new operator to allocate an array of 20 characters.
    char *AnArray = new char[20];

    for( int i = 0; i < 20; ++i )
    {
        // On the first iteration of the loop, allocate
        //  another array of 20 characters.
        if( i == 0 )
        {
            char *AnotherArray = new char[20];
        }
    }

    delete [] AnotherArray; // Error: pointer out of scope.
    delete [] AnArray;      // OK: pointer still in scope.
}

在上面的示例中，指针 AnotherArray 一旦超出范围，将无法再删除对象。

new 的工作原理

new-expression（包含 new 运算符的表达式）执行三项操作：

• 定位并保留要分配的对象的存储。 此阶段完成后，将分配正确的存储量，但它还不是对象。

• 初始化对象。 初始化完成后，将为成为对象的已分配存储显示足够的信息。

• 返回指向对象的指针，该对象所属的指针类型派生自 new-type-id 或 type-id。 程序使用此指针来访问最近分配的对象。

new 运算符调用函数 operator new。 对于任何类型的数组以及不属于 class、struct 或 union 类型的对象，调用全局函数 ::operator new 来分配存储。 类类型对象可基于每个类定义其自身的 operator new 静态成员函数。

当编译器遇到用于分配类型为 T 的对象的 new 运算符时，它会发出对 T::operator new( sizeof(T) ) 的调用，如果未定义用户定义的 operator new，就会调用 ::operator new( sizeof(T) )。 new 运算符就是用这种方式为对象分配正确的内存量。

注意

operator new 的参数属于 std::size_t 类型。 此类型是在 <direct.h>、<malloc.h>、<memory.h>、<search.h>、<stddef.h>、<stdio.h>、<stdlib.h>、<string.h> 和 <time.h> 中定义的。

语法中的选项允许指定 new-placement（请参阅 new 运算符的语法）。 new-placement 参数只能用于用户定义的 operator new 实现；它允许将额外信息传递给 operator new。 如果类 T 具有成员 operator new，那么具有 new-placement 字段（例如 T *TObject = new ( 0x0040 ) T;）的表达式将转换为 T *TObject = T::operator new( sizeof( T ), 0x0040 );，否则就会转换为 T *TObject = ::operator new( sizeof( T ), 0x0040 );。

new-placement 字段的初始用途是为了能在用户指定的地址分配硬件相关对象。

注意

尽管上述示例在 new-placement 字段中只显示了一个参数，但通过此方式传递给 operator new 的额外参数数目并没有限制。

即使已为类类型 T 定义了 operator new，也可以显式使用全局运算符 new，如以下示例所示：

T *TObject = ::new TObject;

范围解析运算符 (::) 强制使用全局 new 运算符。

另请参阅

带一元运算符的表达式
关键字
new 和 delete 运算符