C++11 member initializer list vs in-class initializer?

by

No, these are not the same.

The difference between them is the same that applies for direct-initialization vs. copy-initialization, which is subtle but often very confusing.

§12.6.2 [class.base.init]:

  1. The expression-list or braced-init-list in a mem-initializer is used to initialize the designated subobject (or, in the case of a delegating constructor, the complete class object) according to the initialization rules of 8.5 for direct-initialization. […]

  2. In a non-delegating constructor, if a given non-static data member or base class is not designated by a mem-initializer-id (including the case where there is no mem-initializer-list because the constructor has no ctor-initializer) and the entity is not a virtual base class of an abstract class (10.4), then

    — if the entity is a non-static data member that has a brace-or-equal-initializer, the entity is initialized as specified in 8.5;

§8.5 [dcl.init]:

  1. The initialization that occurs in the form

    T x = a;

as well as in argument passing, function return, throwing an exception (15.1), handling an exception (15.3), and aggregate member initialization (8.5.1) is called copy-initialization.

Initializing a non-static data member on a member-initializer-list follows the rules of direct-initialization, which doesn’t create intermediate temporaries that need to be moved/copied (if compiled without a copy-elision), neither the type of the data member must be copyable/movable (even if the copy is elided). In addition, a direct-initialization introduces an explicit context, while a copy-initialization is non-explicit (if a constructor selected for the initialization is explicit, the program won’t compile).

In other words, the obj s = obj("value"); syntax won’t compile if obj is declared as:

struct obj
{
    obj(std::string) {}
    obj(const obj&) = delete;
};

or:

struct obj
{
    obj(std::string) {}
    explicit obj(const obj&) {}
};

As a more tangible example, while the below won’t compile:

struct any
{
   std::atomic<int> a = std::atomic<int>(1); // ill-formed: non-copyable/non-movable
   std::atomic<int> b = 2; // ill-formed: explicit constructor selected
};

this one will:

struct any
{
    std::atomic<int> a;
    std::atomic<int> b{ 2 };
    any() : a(1) {}
};

Which way is better (performance) ?

With a copy-elision enabled both have identical performance. With copy-elision disabled, there is an additional copy/move constructor call upon every instantiation when the copy-initialization syntax is used (that obj s = obj("value"); is one of).

Is there another way ?

The brace-or-equal-initializer syntax allows one to perform a direct-list-initialization as well:

class any {
public:
    obj s{ "value" };
    any() {}
};

Are there any other differences?

Some other differences that are worth mentioning are:

  1. Brace-or-equal-initializer must reside in a header file along with a class declaration.
  2. If both are combined, member-initializer-list takes priority over brace-or-equal-initializer (that is, brace-or-equal-initializer is ignored).
  3. (C++11 only, until C++14) A class that uses brace-or-equal-initializer violates constraints for an aggregate type.
  4. With the brace-or-equal-initializer syntax it’s not possible to perform a direct-initialization other than a direct-list-initialization.

More Related Contents:

  1. Why is list initialization (using curly braces) better than the alternatives?
  2. How to emulate C array initialization “int arr[] = { e1, e2, e3, … }” behaviour with std::array?
  3. What are the differences between C-like, constructor, and uniform initialization?
  4. Why can’t simple initialize (with braces) 2D std::array? [duplicate]
  5. What are the advantages of list initialization (using curly braces)?
  6. C++11 allows in-class initialization of non-static and non-const members. What changed?
  7. How to initialize std::array elegantly if T is not default constructible?
  8. C++11: Correct std::array initialization?
  9. Now that we have std::array what uses are left for C-style arrays?
  10. Initializing container of unique_ptrs from initializer list fails with GCC 4.7
  11. too many initializers for ‘int [0]’ c++
  12. Has the new C++11 member initialization feature at declaration made initialization lists obsolete?
  13. Different ways of initializing an object in c++
  14. What’s the difference between parentheses and braces in c++ when constructing objects
  15. Initialization difference with or without curly braces in C++
  16. Is there a way to statically-initialize a dynamically-allocated array in C++?
  17. Initializing an std::array of non-default-constructible elements?
  18. What’s the difference between constexpr and const?
  19. Returning unique_ptr from functions
  20. How to capture a unique_ptr into a lambda expression?
  21. Is this behavior of vector::resize(size_type n) under C++11 and Boost.Container correct?
  22. What are the advantages of using nullptr?
  23. Why does std::array not have an constructor that takes a value for the array to be filled with?
  24. Does the C++ volatile keyword introduce a memory fence?
  25. Initializer list not working with vector in Visual Studio 2012? [duplicate]
  26. What does the void() in decltype(void()) mean exactly?
  27. Why does std::istringstream appear to resolve differently to std::ifstream in the ternary (?:) operator?
  28. C++11 anonymous union with non-trivial members
  29. Why does constexpr static member (of type class) require a definition?
  30. C++ 11: Calling a C++ function periodically

Leave a Comment