What are the differences between C-like, constructor, and uniform initialization?

by

First, I would recommend looking at the following talk by Herb Sutter, in which he gives some recommendations about the subject. The brace-initialization discussion starts at around 23:00.

When you are talking about primitive data types, all 3 yield the same result. I personally prefer sticking with the old int x = 0 syntax, but it comes down to personal preference.

For class types, brace initialization and old-school constructor initialization are not completely interchangeable. For example:

vector<int> v (100); // Creates a 100-element vector
vector<int> v {100}; // Creates a 1-element vector, holding the value 100.

This is because std::vector has a constructor that explicitly defines std::initializer_list as its only argument. Keep in mind that

auto var = {1, 2};

creates a std::initializer_list, with var as its identifier.

The thing about initializer lists is that they provide consistency that is a welcome change from what was available beforehand. For example, if you were to initialize an array in C++, you would use:

int arr[] = {1, 2, 3, 4};

But, if you wanted to initialize a vector<int> with the same elements, you either had to:

  1. Initialize the above arr first and then pass arr and arr + 4
  2. Create the vector and push_back() the elements individually or in a loop.

With C++11, you could just use

vector<int> v = {1, 2, 3, 4}; // Same syntax. Nice! Note that the = is optional

Another instance in which brace initialization is helpful is that it provides a workaround to C++’s most vexing parse. From the talk, assume that we have two classes, origin and extents, whose instances can be passed to construct another object of type rectangle. The following statement:

rectangle w(origin(), extents());

doesn’t allow you to create a rectangle object using origin and extents temporaries, because that statement is parsed as a function declaration. Tsk tsk. So normally, you would have to do:

origin  o;
extents e;
rectangle w(o, e);

With brace initialization, you can create them on the fly, and

rectangle w {origin(), extents()};

will work as intended, i.e. passed to the constructor which is overloaded with an origin object as it’s first argument and an extents object as the second.

The rule is for objects, use brace initialiation unless you have a reason not to.

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. Why can’t simple initialize (with braces) 2D std::array? [duplicate]
  4. What are the advantages of list initialization (using curly braces)?
  5. Can virtual functions have default parameters?
  6. C++11 allows in-class initialization of non-static and non-const members. What changed?
  7. initialize a const array in a class initializer in C++
  8. How to initialize std::array elegantly if T is not default constructible?
  9. C++11: Correct std::array initialization?
  10. Now that we have std::array what uses are left for C-style arrays?
  11. Default, value and zero initialization mess
  12. C++11 member initializer list vs in-class initializer?
  13. Initializing container of unique_ptrs from initializer list fails with GCC 4.7
  14. Do these members have unspecified ordering?
  15. Can C++ code be valid in both C++03 and C++11 but do different things?
  16. too many initializers for ‘int [0]’ c++
  17. Has the new C++11 member initialization feature at declaration made initialization lists obsolete?
  18. Different ways of initializing an object in c++
  19. What’s the difference between parentheses and braces in c++ when constructing objects
  20. What’s the difference between Radio r = Radio(“PSR”, 100.8) and Radio(“PSR”, 100.8)?
  21. What differences, if any, between C++03 and C++11 can be detected at run-time?
  22. Initialization difference with or without curly braces in C++
  23. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  24. Calling delete on NULL pointers – C++03 vs C++11
  25. Is there a way to statically-initialize a dynamically-allocated array in C++?
  26. Initializing an std::array of non-default-constructible elements?
  27. Difference between angle bracket < > and double quotes ” ” while including header files in C++? [duplicate]
  28. How to parse a date string into a c++11 std::chrono time_point or similar?
  29. What is the difference between MinGW, MinGW-w64 and MinGW-builds?
  30. How can I resize a 2D vector of objects given the width and height?

Leave a Comment