使用构造函数与带括号的初始值设定项列表初始化类和结构的规则是什么？

Question

我已经在网上搜索了这个问题的答案，但我还没有找到一个满意的答案。我想知道初始化结构和类类型的对象的所有规则是什么，特别是在构造函数与带括号的初始化列表方面。结构与类的规则也不同吗？

让我们假设有一个名为矩形的类或结构。

#include <iostream>
using namespace std;

class Rectangle {
  public:
    Rectangle() : x(5.0), y(6.0), width(7.0), height(8.0) {}

    void printMe()
    {
        cout << "The rectangle is located at (" << x << ',' << y << ") and is " << width << " x " << height << endl;
    }
    double x;
    double y;
    double width;
    double height;
};


int main()
{
    Rectangle r = {0.0, 0.0, 3.0, 4.0};
    r.printMe();

    Rectangle s;  // uninitialized!
    s.printMe();
}

我尝试用C语言中通常使用的方式初始化矩形r，使用一个普通的带括号的初始值设定项列表。但是，g给出以下错误：

constructor_vs_initializer_list.cpp: In function ‘int main()’:
constructor_vs_initializer_list.cpp:21:38: error: could not convert ‘{0.0, 0.0, 3.0e+0, 4.0e+0}’ from ‘<brace-enclosed initializer list>’ to ‘Rectangle’
     Rectangle r = {0.0, 0.0, 3.0, 4.0};
                                      ^

嗯……嗯。。。。乍一看，这并不是很有用的错误消息。然而，我认为它与构造函数有关，因为如果我删除它，代码就会编译并运行！我认为这是一个悖论，带括号的初始值设定项列表和构造函数似乎都在竞争初始化数据成员。

但是，当我将数据成员私有时，在删除构造函数后，再次显示相同的错误消息！

我想知道数据成员初始化的优先规则是什么。大括号初始值设定项列表与您自己定义的构造函数相比如何？它与C 11特性相比如何：=默认构造函数和类内成员初始值设定项？我假设这些初始化对象数据成员的不同方法会以某种方式相互冲突。

Rectangle() = default;
...
double x = 1.0;

我并不是说把它们混在一起一定是好代码，只是我认为这是代码，而且代码应该被很好地理解。非常感谢。




Answer 1

CPP标准草案n4713就聚合初始化声明了这一点：

11.6.1聚合[dcl.init.aggr]
1聚合是具有
（1.1）-没有用户提供的、显式的或继承的构造函数，
（1.2）-没有私有或受保护的非静态数据成员的数组或类

在您的情况下，第一种情况下有用户提供的构造函数，第二种情况下有私有数据成员，这分别违反了上述（1.1）和（1.2）要点。

Answer 2

这里有一个例子来说明这些差异。C中的初始化相当复杂。请参见：https://blog.tartanllama.xyz/initialization-is-bonkers/.

通常最好使用默认成员初始化器或初始化列表。您在构造函数中做了正确的事情。只需使用直接列表初始化或直接初始化调用构造函数以避免混淆人们。通常，您只会使用复制列表初始化来初始化聚合，而无需用户提供的构造函数。

#include <iostream>

struct A {
    int i;
};

struct B {
    B() = default;
    int i;
};

struct C {
    C();
    int i;
};

C::C() = default;

struct D {
    D(){};
    int i;
};

struct E : public D {
};

struct F {
    F(int i = 5) {}
    int i;
};

struct G {
    G() = delete;
    int i;
};

int main() {
    // g++ (v 8.2.1) provides good warnings about uninitialized values.
    // clang++ (v 7.0.1) does not.
    // Technically, they are initialized to 'indeterminate values', but it is
    // easier to refer to the member variables as uninitialized.

    {
        // All of the following are 'default initialized', meaning they are not even
        // zero-initialized. Members are UNINITIALIZED (Technically, they are
        // initialized to 'indeterminate' values.
        // Either nothing is done, or the default constructor is called (in
        // which nothing is done).
        A a;
        B b;
        C c;
        D d;
        E e;
        F f;

        std::cout << "a: " << a.i << std::endl;
        std::cout << "b: " << b.i << std::endl;
        std::cout << "c: " << c.i << std::endl;
        std::cout << "d: " << d.i << std::endl;
        std::cout << "e: " << e.i << std::endl;
        std::cout << "f: " << f.i << std::endl;
        std::cout << std::endl;
    } {
        // This is more complex, as these are all 'list initialized'.
        // Thank you, infinite wisdom of the C++ committee.

        A a{};
        // Direct list initialization -> aggregate initialization
        //  - A has no user-provided constructor and
        // thus is an aggregate, and agg. init. takes place.
        // This 'value initializes' all *MEMBERS* (unless a default member
        // initializer exists, which it does not here).
        // Value initialization of non-class types results in
        // zero-initialization. (member `i` is zero-initialized)

        A a2 = {};
        // same thing, but via copy list initialization

        A a3{{}};
        // recursive, initializes `i` with {}, which zero initializes `i`.

        A a4{0};
        // recursive, initializes `i` 0;
        // Could also do `A a4 = {0}`

        A a5{a};
        // direct intialization of `a5` with `a`.
        // Implicit copy constructor chosen by overload resolution.

        A a6{A{}};
        // post C++17, direct initializes a6 with a prvalue of type A, that is
        // aggregate initialized as above. NOT copy/move initialized, but
        // instead initialized via the "initializer expression itself".
        // I assume this means the value of a6 is directly set via as if it were
        // being aggregate initialized.

        B b{};
        // Same as A. `B() = default;` does NOT specify a user-provided
        // constructor

        C c{};
        // Because the first declaration of `C()` is not `C() = default;`,
        // this DOES have a user-provided constructor, and 'value initializaton'
        // is performed.
        // NOTE: this value intializes `C`, not the *MEMBERS* of `C`.
        // Because `C` is a normal class type, value initialization just calls
        // the default constructor, which does nothing, and leaves all members
        // uninitialized.

        D d{};
        // D is a class type that is list/direct initialization -> value
        // inititalizaton -> default initialization -> call constructor ->
        // members are left unitialized.

        E e{};
        // List initialization -> value initialization -> default initialization
        // -> calls implicitly defined default constructor -> Calls default
        // constructor of bases -> leaves E::D.i uninitialized

        F f{};
        // List/direct initialization -> value initialization -> calls default
        // constructor with default arguments -> leaves F.i uninitialized

        // G g{}; 
        // Fails to compile.
        // list initialization -> value initialization -> default initialization
        // -> deleted default constructor selected by overload resolution ->
        // fails to compile

        std::cout << "a: " << a.i << std::endl;
        std::cout << "a2: " << a2.i << std::endl;
        std::cout << "a3: " << a3.i << std::endl;
        std::cout << "a4: " << a4.i << std::endl;
        std::cout << "a5: " << a5.i << std::endl;
        std::cout << "a6: " << a6.i << std::endl;
        std::cout << "b: " << b.i << std::endl;
        std::cout << "c: " << c.i << std::endl;
        std::cout << "d: " << d.i << std::endl;
        std::cout << "e: " << e.i << std::endl;
        std::cout << "f: " << f.i << std::endl;
    }
}