Is there a difference between "my_constructor : variable(x)" and "this.variable = x" in constructor?

Question

Is there a difference between Demo1 and Demo2 in the following code?

#include <iostream>

class Base {};

class Demo1 : public Base {
public:
    Demo1() : instance_variable(5) {

    }

    int instance_variable;
};

class Demo2 : public Base {
public:
    Demo2() {
        this->instance_variable = 5;
    }

    int instance_variable;
};

int main(int argc, char **argv) 
{    
    Demo1 a;    
    Demo2 b;

    std::cout << "a.instance_variable: " << a.instance_variable << std::endl;
    std::cout << "b.instance_variable: " << b.instance_variable << std::endl;

    return 0;
} 

I saw the first notation in a book I am reading right now, and I am not sure if the two are equivalent or if Demo1 has subtle differences I should be aware of.

I find the second much more readable as I am coming from a Java/JavaScript background, so I am curious if I can replace "Demo1" with "Demo2" without changing the meaning of the code.

Also, what is the expression "constructor:field(x){}" called?

Answer 1

There can be a difference. As a result the first approach, the constructor initializer syntax, is considered better.

In Demo2, everything gets default-initialized and then the operator= is used to give the new value. Since your instance_variable is just an int, this doesn't matter. But it will matter if:

• the default constructor, operator=, or both are computationally expensive
• there is no default constructor
• the variable is const or a reference, meaning you can't use operator= to change the value
• the variable is an instance of a class that has been written counter-intuitively, so that you actually get different results from a constructor that takes an argument than from a default constructor followed by assignment. While such classes shouldn't exist, that doesn't mean they don't.

Since the Demo1 way is sometimes faster (never slower) and works in cases where the Demo2 way doesn't, it is the preferred technique. While it may feel unusual to those coming from other languages, it is the way you should write your constructors.

Answer 2

If you have a programming background (as you said, you have), you should be well aware of the difference between initializing value to variable and assignment of a value to some variable.

Demo1 is using the variable initialization (instance_variable is being initialized in the member initializer list, Demo() : instance_variable(5)), but Demo2 is assigning value to the instance_variable

I am not sure if the two are equivalent or if Demo1 has subtle differences I should be aware of.

No. The two aren't equivalent.

• Demo1 is initializing the instance_variable, it means copy constructor will be called (in the case, when instance_variable is object).
• But the Demo2 is assigning value to the variable after it has been initialized (default constructor has been called, and now operator= will be called to copy values)

Also, what is the expression constructor:field(x){} called?

It's called member initializer list.

EDIT

Member initializer list only makes a difference when initializing objects, but in case of primitives, both ways (Demo1 and Demo2), they're pretty much the same.

And there's another thing that you should know, is, that you'll have to use member initializer list to initialize:

• const data members
• member reference variables
• initializing those member variables (objects of some class), which don't have any default constructor.
• and when passing parameters to base class constructor.

Answer 3

Demo1 uses a member initializer list. It calls the constructor of instance_variable with the argument 5.

Demo2 uses the copy assignment operator of instance_variable with the argument 5.

In your case, since instance_variable is an int, there is no difference. However, if instance_variable was some object of a class that behaves differently on initialization and copy assignment, there would be a difference.

Answer 4

1. this is called "member initialization"
2. for and int it makes no difference. for complex object, the member init will call the member's c-tor once with the needed params, instead of calling the default cotr and then setting up the properties manually.

Answer 5

Using Member Initializer list (demo 1):

A.) Copy constructor of the variable is called as instance_variable(value). B.) Destructor is called when value goes out of scope.

copy constructor + destructor call

Initialization inside constructor block (demo 2): A.) Copy constructor of the variable is called as instance_variable(value). B.) Assignment operator call inside constructor body. C.) Destructor is called when value goes out of scope.

constructor + one addition assignment operator call(for complex and Non-PODs) + destructor 

This assignment penalty will be much more in “real” applications where there will be many such complex objects to initialize. You are doing int assignment, so no difference IMO.

Read more.