new的规则类似于初始化具有自动存储持续时间的对象时所发生的情况(尽管由于令人烦恼的解析，语法可能略有不同)。

如果我说:

int my_int; // default-initialize → indeterminate (non-class type)

那么my_int有一个不确定的值，因为它是非类类型。或者，我可以像这样对my_int进行值初始化(对于非类类型，是零初始化):

int my_int{}; // value-initialize → zero-initialize (non-class type)

(当然，我不能使用()，因为这将是一个函数声明，但int()的工作原理与int{}相同，可以构造一个临时。)

然而，对于类类型:

Thing my_thing; // default-initialize → default ctor (class type)
Thing my_thing{}; // value-initialize → default-initialize → default ctor (class type)

调用默认构造函数来创建Thing，没有异常。

所以，规则或多或少是:

Is it a class type? YES: The default constructor is called, regardless of whether it is value-initialized (with {}) or default-initialized (without {}). (There is some additional prior zeroing behavior with value-initialization, but the default constructor is always given the final say.) NO: Were {} used? YES: The object is value-initialized, which, for non-class types, more or less just zero-initializes. NO: The object is default-initialized, which, for non-class types, leaves it with an indeterminate value (it effectively isn't initialized).

这些规则精确地转换为新语法，添加的规则()可以代替{}，因为new永远不会被解析为函数声明。所以:

int* my_new_int = new int; // default-initialize → indeterminate (non-class type)
Thing* my_new_thing = new Thing; // default-initialize → default ctor (class type)
int* my_new_zeroed_int = new int(); // value-initialize → zero-initialize (non-class type)
     my_new_zeroed_int = new int{}; // ditto
       my_new_thing = new Thing(); // value-initialize → default-initialize → default ctor (class type)

(这个答案包含了c++ 11中概念上的变化，上面的答案目前没有;值得注意的是，一个新的标量或POD实例将以一个不确定的值结束，现在技术上是默认初始化的(对于POD类型，技术上调用一个普通的默认构造函数)。虽然这并没有引起行为上的实际变化，但它确实在一定程度上简化了规则。)

新事物();是显式的，你想要一个构造函数调用while new Thing;表示您不介意不调用构造函数。

如果在带有用户定义构造函数的结构/类上使用，则没有区别。如果在一个普通的struct/类上调用(例如struct Thing {int i;};)然后new Thing;是像malloc(大小(东西));而new Thing();是像calloc(sizeof(Thing));-它得到零初始化。

问题就在这两者之间:

struct Thingy {
  ~Thingy(); // No-longer a trivial class
  virtual WaxOn();
  int i;
};

新事物的行为;vs new Thingy();在这种情况下，在c++ 98和c++ 2003之间变化。详见Michael Burr的解释。

假设Test是一个定义了构造函数的类，没有区别。后一种形式更清楚地表明Test的构造函数正在运行，但仅此而已。

不，它们是一样的。但两者之间是有区别的:

Test t;      // create a Test called t

and

Test t();   // declare a function called t which returns a Test

这是因为c++(和C)的基本规则:如果某个东西可以是声明，那么它就是声明。

编辑:关于POD和非POD数据的初始化问题，虽然我同意已经说过的一切，但我只是想指出，这些问题只适用于新构造的东西或其他构造方法没有用户定义的构造函数。如果有这样的构造函数，将使用它。99.99%的合理设计的类都有这样的构造函数，因此可以忽略这个问题。

让我们来研究一下，因为有些差异实际上会影响代码的行为。以下大部分内容摘自对一篇“新旧事物”文章的评论。

有时new操作符返回的内存将被初始化，有时则不会，这取决于您要更新的类型是POD(普通旧数据)，还是包含POD成员并使用编译器生成的默认构造函数的类。

在c++ 1998中，有两种初始化类型:0和default 在c++ 2003中增加了第三种初始化类型，值初始化。

假设:

struct A { int m; }; // POD
struct B { ~B(); int m; }; // non-POD, compiler generated default ctor
struct C { C() : m() {}; ~C(); int m; }; // non-POD, default-initialising m

在c++ 98编译器中，应该发生以下情况:

新A -不定值 new A() -零初始化 new B -默认构造(B::m未初始化) new B() -默认构造(B::m未初始化) 新建C -默认构造(C::m为零初始化) new C() -默认构造(C::m是零初始化的)

在c++ 03兼容的编译器中，事情应该这样工作:

新A -不定值 new A() - value-initialize A，这是零初始化，因为它是一个POD。 new B -默认初始化(保留B::m未初始化) new B() - value- initialization B，它对所有字段进行零初始化，因为它的默认ctor是编译器生成的，而不是用户定义的。 new C - default-初始化C，它调用默认的ctor函数。 new C() -值初始化C，它调用默认的ctor。

所以在c++的所有版本中，新a和新a()之间是有区别的，因为a是POD。

对于new B()的情况，c++ 98和c++ 03之间的行为有所不同。

这是c++的一个让你抓狂的角落。在构造一个对象时，有时你想要/需要paren，有时你绝对不能拥有它们，有时这无关紧要。

我在下面写了一些示例代码，作为Michael Burr回答的补充:

#include <iostream>

struct A1 {
    int i;
    int j;
};

struct B {
    int k;
    B() : k(4) {}
    B(int k_) : k(k_) {}
};

struct A2 {
    int i;
    int j;
    B b;
};

struct A3 {
    int i;
    int j;
    B b;
    A3() : i(1), j(2), b(5) {}
    A3(int i_, int j_, B b_): i(i_), j(j_), b(b_) {}
};

int main() {
    {
        std::cout << "Case#1: POD without ()\n";
        A1 a1 = {1, 2};
        std::cout << a1.i << " " << a1.j << std::endl;
        A1* a = new (&a1) A1;
        std::cout << a->i << " " << a->j  << std::endl;
    }
    {
        std::cout << "Case#2: POD with ()\n";
        A1 a1 = {1, 2};
        std::cout << a1.i << " " << a1.j << std::endl;
        A1* a = new (&a1) A1();
        std::cout << a->i << " " << a->j  << std::endl;
    }
    {
        std::cout << "Case#3: non-POD without ()\n";
        A2 a1 = {1, 2, {3}};
        std::cout << a1.i << " " << a1.j << " " << a1.b.k << std::endl;
        A2* a = new (&a1) A2;
        std::cout << a->i << " " << a->j << " " << a->b.k << std::endl;
    }
    {
        std::cout << "Case#4: non-POD with ()\n";
        A2 a1 = {1, 2, {3}};
        std::cout << a1.i << " " << a1.j << " " << a1.b.k  << std::endl;
        A2* a = new (&a1) A2();
        std::cout << a->i << " " << a->j << " " << a1.b.k << std::endl;
    }
    {
        std::cout << "Case#5: user-defined-ctor class without ()\n";
        A3 a1 = {11, 22, {33}};
        std::cout << a1.i << " " << a1.j << " " << a1.b.k << std::endl;
        A3* a = new (&a1) A3;
        std::cout << a->i << " " << a->j << " " << a->b.k << std::endl;
    }
    {
        std::cout << "Case#6: user-defined-ctor class with ()\n";
        A3 a1 = {11, 22, {33}};
        std::cout << a1.i << " " << a1.j << " " << a1.b.k  << std::endl;
        A3* a = new (&a1) A3();
        std::cout << a->i << " " << a->j << " " << a1.b.k << std::endl;
    }
    return 0;
}

/*
output with GCC11.1(C++20)
Case#1: POD without ()
1 2
1 2
Case#2: POD with ()
1 2
0 0
Case#3: non-POD without ()
1 2 3
1 2 4
Case#4: non-POD with ()
1 2 3
0 0 4
Case#5: user-defined-ctor class without ()
11 22 33
1 2 5
Case#6: user-defined-ctor class with ()
11 22 33
1 2 5
*/