Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Has the new C++11 member initialization feature at declaration made initialization lists obsolete?

With C++11, we now have the ability to initialize class members in a header declaration:

class aClass {     private:         int mInt{100};     public:          aClass();         ~aClass(); }; 

So I'm a bit confused. Traditionally initialization lists in constructors have been used for member initialization:

aClass::aClass() : mInt(100) {     ... } 

Has the new C++11 member initialization feature at declaration made initialization lists obsolete? If not, what are the advantages of one over the other? What situations would make initialization at declaration advantageous, or initialization lists advantageous? When should one be used over the other?

like image 492
Vector Avatar asked Jun 10 '14 20:06

Vector


People also ask

Why is initializing a class member variable during declaration not permitted?

The main reason is that initialization applies to an object, or an instance, and in the declaration in the class there is no object or instance; you don't have that until you start constructing.

When must you use a member initializer list?

Initializer List is used in initializing the data members of a class. The list of members to be initialized is indicated with constructor as a comma-separated list followed by a colon. Following is an example that uses the initializer list to initialize x and y of Point class.

Should member variables be initialized?

You should always initialize native variables, especially if they are class member variables. Class variables, on the other hand, should have a constructor defined that will initialize its state properly, so you do not always have to initialize them.

What is member initialization list in C++?

Member initializer list is the place where non-default initialization of these objects can be specified. For bases and non-static data members that cannot be default-initialized, such as members of reference and const-qualified types, member initializers must be specified.


2 Answers

No, they are not obsolete as this article Get to Know the New C++11 Initialization Forms says in the Class Member Initialization section (emphasis mine):

Bear in mind that if the same data member has both a class member initializer and a mem-init in the constructor, the latter takes precedence. In fact, you can take advantage of this behavior by specifying a default value for a member in the form of a class member initializer that will be used if the constructor doesn't have an explicit mem-init for that member. Otherwise, the constructor's mem-init will take effect, overriding the class member initializer. This technique is useful in classes that have multiple constructors

So although in class member initialization is a nice convenience it does not remove the need for initialization lists but both features instead work together to give you a nice way to specify default values and override them when needed. This seems to be also how Bjarne Stroustrup sees it too, he says:

This saves a bit of typing, but the real benefits come in classes with multiple constructors. Often, all constructors use a common initializer for a member:

and provides an example of members which have a common initializer:

class A {   public:     A(): a(7), b(5), hash_algorithm("MD5"), s("Constructor run") {}     A(int a_val) : a(a_val), b(5), hash_algorithm("MD5"), s("Constructor run") {}     A(D d) : a(7), b(g(d)), hash_algorithm("MD5"), s("Constructor run") {}     int a, b;   private:     HashingFunction hash_algorithm;  // Cryptographic hash to be applied to all A instances     std::string s;                   // String indicating state in object lifecycle }; 

and says:

The fact that hash_algorithm and s each has a single default is lost in the mess of code and could easily become a problem during maintenance. Instead, we can factor out the initialization of the data members:

class A {   public:     A(): a(7), b(5) {}     A(int a_val) : a(a_val), b(5) {}     A(D d) : a(7), b(g(d)) {}     int a, b;   private:     HashingFunction hash_algorithm{"MD5"};  // Cryptographic hash to be applied to all A instances     std::string s{"Constructor run"};       // String indicating state in object lifecycle }; 

Note: disadvantage in C++11

There is one disadvantage to using in class member initialization in C++11 since it makes a class a non-aggregate we can no longer use aggregate initialization which may be rather surprising. This is not the case in C++14 where this restriction was removed. See: C++11 aggregate initialization for classes with non-static member initializers for more details.

like image 178
Shafik Yaghmour Avatar answered Oct 21 '22 20:10

Shafik Yaghmour


No, they are not obsolete.

Initialization lists are still the only way to go if you need a constructor's arguments to initialize your class members.

class A {   int a=7; //fine, give a default value public:   A(); };  class B {   int b;  public:   B(int arg) : b(arg) {}    B(int arg, bool b) : b(arg) { ... } }; 

Note that if both are present, the constructor's initialization will take effect, overriding the class member initialization, which is useful to specify a default value for a class member.

like image 37
quantdev Avatar answered Oct 21 '22 20:10

quantdev