聚合初始化与统一初始化

Question

The more I read about C++11 uniform initialization, the more confused I am. Scott Meyers in Effective Modern C++ (page 55) says that the statement

Widget w2{};

always calls the default constructor (even in the presence of constructor with a std::initializer_list argument).

At first sight, this seems to be consistent with the 4th edition of Stroustrup book "C++ programing language", eg according to the table on page 1200 the statement

std::atomic<T> x;

leaves the atomic variable uninitialized, while

std::atomic<T> x {};

calls "default constructor" so that x represents a value initialized T object.

However, I can't believe that std::atomic<T> x; does not call the default constructor in C++11 anymore, so I'm totally confused here.

Finally, after taking a look at C++11 standard (n3337 draft) my confusion is even bigger. On page 1102 we have:

template <> struct atomic<integral > {
  //[...] list of non-constructor functions
  atomic() noexcept = default;
  constexpr atomic(integral ) noexcept;
  atomic(const atomic&) = delete;
  //[...] other non-constructor functions
};

While on page 1104 (point 29.5.5) we see

The atomic integral specializations and the specialization atomic shall have standard layout. They shall each have a trivial default constructor and a trivial destructor. They shall each support aggregate initialization syntax.

So classes with user defined constructor now support aggregate initialization? Is this so because the constuctor is constexpr ?

And what happens when we write

std::atomic<T> x {};

Is this the aggregate initialization? Or a call to the (trivial) default constructor?

Answer 1

So classes with user defined constructor now support aggregate initialization?

Only aggregates support aggregate initialization. An aggregate can have a user defined constructor only if the constructor is defined as defaulted or deleted.

This will change in C++20 where no user declared constructors are allowed at all.

Is this so because the constuctor is consexpr?

constexpr has no effect on this.

 std::atomic<T> x {};

Is this the aggregate initialization?

This is list initialization. If the type is an aggregate, then list initialization would aggregate initialize the object. std::atomic is not an aggregate, because it has a user-provided constructor that is neither defaulted nor deleted:

 constexpr atomic( T desired ) noexcept; // (2) (since C++11)

For std::atomic , this rule of list initialization applies:

• Otherwise, if the initializer list has no elements and T is a class type with a default constructor, the object is value-initialized .

And value initialization invokes the default constructor for such class.