new-expression :
:: _opt new new-placement _opt new-type-id new-initializer _opt
:: _opt new new-placement _opt ( type-id ) new-initializer _opt

new-placement :
( expression-list )

new-type-id :
type-specifier-seq new-declarator _opt

new-declarator :
ptr-operator new-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() {
对使用 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 运算符