How are an objects instance variables initialized of a class has only a default constructor?

Answer 1

You have to explicitly initialise all instance variables, otherwise their values will be initialised to whatever happens to be in memory at the time they are instantiated.

Consider the following class which has no explicit initialisation:

#include <iostream>

class object

{

public:

object(){}

public:

const int getData( void ) const { return( m_data ); }

private:

int m_data;

};

int main()

{

object O;

printf( "O.m_data = %d\n", O.getData() );

return( 0 );

}

Example output:

O.m_data = -858993460

This is not particularly useful; we must ensure m_data is initialised before we access its value.

One way to initialise object::m_data is from within the body of the constructor:

object(){ m_data = 0; } // inefficient initialisation

However this is quite inefficient because object::m_data will have already be instantiated by the time we got to the constructor body. This is akin to the following C-style initialisation:

int x; // instantiate x

x = 0; // initialise x

When what we really want to do is:

int x = 0;

Or use the more formal construction semantics:

int x(0);

Both achieve the same thing. They both initialise the variable x at the point of instantiation, not after instantiation. Fortunately, C++ allows us to initialise all instance variables at the point of instantiation, via the constructor's initialisation section:

object():m_data(0){} // efficient initialisation

While initialising a single primitive data type in the constructor body isn't going to cause major problems in terms of efficiency, with more complex data types the inefficiencies can very quickly add up. Thus it is important to use the initialisation section as much as possible and to only use the body of the constructor when there is no option.

The initialisation section is particularly important when dealing with derived classes. Consider the following:

#include <iostream>

class base

{

public:

base():m_int(0){}

base(const base& object):m_int(object.m_int){}

public:

const int getInt( void ) const { return( m_int ); }

void setInt( const int data ) { m_int = data; }

private:

int m_int;

};

class derived : public base

{

public:

derived():m_float(0.0){}

derived(const derived& object):m_float(object.m_float){}

public:

const float getFloat( void ) const { return( m_float ); }

void setFloat( const float data ) { m_float = data; }

private:

float m_float;

};

int main()

{

derived d;

d.setInt( 1 );

d.setFloat( 2.0 );

printf( "d.getInt() = %d, d.getFloat() = %f\n", d.getInt(), d.getFloat() );

derived c(d); // call copy constructor.

printf( "c.getInt() = %d, c.getFloat() = %f\n", c.getInt(), c.getFloat() );

return( 0 );

}

Example output:

d.getInt() = 1, d.getFloat() = 2.000000

c.getInt() = 0, c.getFloat() = 2.000000

Note that c should be an exact copy of d, but there's clearly a difference in the integer variables inherited from the base class. This is because the derived class copy constructor called the base class default constructor, not the base class copy constructor as you might have expected. To resolve this we must explicitly call the base class copy constructor and the only way to do so is via the initialisation section of the derived class:

derived(const derived& object):base(object),m_float(object.m_float){}

Note that the derived class' copy constructor now includes a call to base(object) in the initialisation section. This ensures the base class copy constructor is called. Although object is actually an instance of derived, because it derived from base it is also a kind of base, thus the call is legitimate. Now if we run the code we'll get the expected result:

d.getInt() = 1, d.getFloat() = 2.000000

c.getInt() = 1, c.getFloat() = 2.000000

As your classes become more and more complex you will inevitably find yourself creating overloaded constructors to provide a wide variety of initialisation methods. But keep in mind that it costs absolutely nothing to use the initialisation sections even if several constructors end up using the exact same initialisations. And while it is tempting to move all of the common initialisation code into a private method of the class and have each constructor call that method (known as a construction helper function), this simply adds yet more inefficiency by introducing yet another unnecessary function call. Helper functions such as these are undoubtedly useful during the initial development of a class but as soon as the class is finalised, get rid of the helper function and move all that functionality into the initialisation sections where they belong. In the case of derived classes, base class constructors will be called whether you like it or not, so it makes sense to call the most appropriate base class constructor from within the initialisation section of each of your derived class constructors. Remember that if you do not specify a base class constructor, its default constructor will be called implicitly, which may or may not be the most appropriate constructor in all cases (not least in the case of the copy constructor).