Navigation



10.1 — Constructor initialization lists

Up until now, we’ve been initializing our class member data in the constructor using the assignment operator. For example:

class Something
{
private:
    int m_nValue;
    double m_dValue;
    int *m_pnValue;

public:
    Something()
    {
        m_nValue = 0;
        m_dValue = 0.0;
        m_pnValue = 0;
    }
};

When the class’s constructor is executed, m_nValue, m_dValue, and m_chValue are created. Then the body of the constructor is run, where the member data variables are assigned values. This is similar to the flow of the following code in non-object-oriented C++:

int nValue;
double dValue;
int *pnValue;

nValue = 0;
dValue = 0.0;
pnValue = 0;

While this does not exhibit good style, it is valid within the syntax of the C++ language.

So far, the classes that we have written have only included non-const or pointer member variables. However, what happens when we want to use const or reference variables as member variables? As you have learned in previous lessons, const and reference variables must be initialized on the line they are declared. Consider the following example:

class Something
{
private:
    const int m_nValue;
public:
    Something()
    {
        m_nValue = 5;
    }
};

This produces code similar to the following:

const int nValue; // error, const vars must be assigned values immediately
nValue = 5;

Consequently, assigning const or reference member variables values in the body of the constructor is not sufficient.

Initialization lists

C++ provides another way of initializing member variables that allows us to initialize member variables when they are created rather than afterwards. This is done through use of an initialization list.

In the lesson on basic addressing and variable declaration, you learned that you could assign values to variables in two ways: explicitly and implicitly:

int nValue = 5; // explicit assignment
double dValue(4.7); // implicit assignment

Using an initialization list is very similar to doing implicit assignments.

Let’s take a look at our top example again. Here’s the code that does explicit assignments in the constructor body:

class Something
{
private:
    int m_nValue;
    double m_dValue;
    int *m_pnValue;

public:
    Something()
    {
        m_nValue = 0;
        m_dValue = 0.0;
        m_pnValue = 0;
    }
};

Now let’s write the same code using an initialization list:

class Something
{
private:
    int m_nValue;
    double m_dValue;
    int *m_pnValue;

public:
    Something() : m_nValue(0), m_dValue(0.0), m_pnValue(0)
    {
    }
};

The initialization list is inserted after the constructor parameters, begins with a colon (:), and then lists each variable to initialize along with the value for that variable separated by a comma. Note that we no longer need to do the explicit assignments in the constructor body, since the initialization list replaces that functionality. Also note that the initialization list does not end in a semicolon.

Here’s an example of a class that has a const member variable:

class Something
{
private:
    const int m_nValue;
public:
    Something(): m_nValue(5)
    {
    }
};

We strongly encourage you to begin using this new syntax (even if you aren’t using const or reference member variables) as initialization lists are required when doing composition and inheritance (subjects we will be covering shortly).

10.2 — Composition
Index
9.12 — Shallow vs. deep copying


Constructing a website is not that different from building construction. Both code and home inspection are necessary to make sure all features are up to speed, and uniform building code is present in each to ensure consistency and quality.

25 comments to 10.1 — Constructor initialization lists

  • [...] the previous lesson on initializer lists, you learned that the preferred way to initialize class members is through initializer lists rather [...]

  • [...] 10.1 — Constructor initialization lists [...]

  • Daniel

    Hi Alex,

    Just a question, can you use initialisation lists with arrays of members? something like this:

    class Something
    {
    private:
        const int m_nValue[3];
    public:
        Something(): m_nValue(5, 6, 7)
        {
        }
    };

    Or do you have to do it like this:

    class Something
    {
    private:
        const int m_nValue[3];
    public:
        Something(): m_nValue[0](5), m_nValue[1](6), m_nValue[2](7)
        {
        }
    };

    Thanks,
    Daniel

    • Unfortunately, neither of those work. This actually hits on one of the shortcomings of the C++ language — there is no way to initialize non-static array members in C++.

      However, there is a reasonable workaround. Because this is a constant array, we know the value of the members will never change — so why even have one array per class object? It makes more sense to define m_nValue as a static member, so it will be shared by all class objects. That way they all reference the same one and you save memory. And there IS syntax to initialize static array members in C++:

      class Something
      {
      private:
          static const int m_nValue[3];
      public:
          Something()
          {
          }
      };
      
      const int Something::m_nValue[] = {5, 6, 7}
      
      • Santhosh C Rao

        How do I access this variable?

        Something a;
        printf(“%d\n%d\n%d\n”,a.m_nValue[0],a.m_nValue[1],a.m_nValue[2]);

        I was not able to compile when I used this above piece of code.
        If I make this variable as public then I was able to access.
        Can anybody tell me how to access?

        • Because m_nValue is private, you can’t access it from outside the class. The best thing to do would be to add access functions and use those:

          class Something
          {
          private:
              static const int m_nValue[3];
          public:
              Something()
              {
              }
          
              int GetValue(int nIndex)
              {
                  return m_nValue[nIndex];
              }
          };
          
          const int Something::m_nValue[] = {5, 6, 7}
          
          Something a;
          printf(”%d\n%d\n%d\n”, a.GetValue(0), a.GetValue(1), a.GetValue(2));
          
      • Ashish

        class Something
        {
        private:
        static const int m_nValue[3];
        public:
        Something()
        {
        }
        };

        const int Something::m_nValue[] = {5, 6, 7}

        ‘m_nValue’ is a private data member of the class. So how can you access it outside the class and initialize? Ans also static member data are only accessible to static member function.

        Thanks in advance

        • Martin

          Comment by Ashish
          “…static member data are only accessible to static member function.”

          However i am able to access the static member m_nValue from non-static member function GetValue(), as shown in the example below:
          //File static.h
          class Something
          {
          private:
          static const int m_nValue[3];

          public:
          Something()
          {
          }

          int GetValue(int nIndex)
          {
          return m_nValue[nIndex];
          }

          };

          //File static.cpp
          int _tmain(int argc, _TCHAR* argv[]) //using visual studio 2005
          {
          Something a;
          printf (“%d\n%d\n%d\n”, a.GetValue(0), a.GetValue(1), a.GetValue(2));

          return 0;
          }

        • Rahul

          Even if it appears that m_nValue[] is accessed outside the class “Somethig”, but actually it is not.
          In the statement “const int Something::m_nValue[] = {5, 6, 7}”, we are accessing the array from inside the class. It is evident from the “Something::”.

          • cooltoad

            You can access static data from non-static member functions but not the vice versa.

            Imagine that the static data is never tied to an object and hence no this pointer.
            It is something like a global variabble for that class. That is why you can access by ClassName::static_variable.

            If the member function was static, which means it can be invoked even w/o an object being created which means it cannot access non-static data which are tied to this pointer.

  • [...] to be const. You can initialize const member variables in a class in the constructor, using an initialization list. Using these lists is how you should set any necessary member variables for functions, since [...]

  • srividya

    Its a just an awesome example

  • subhransu

    in case this slipped from your radar
    The Constructor initialize list need to initialize always for following
    1) Refrence Variables,
    2) Const Variables
    3) base class constructor(having variable number of arguments).

  • helbawi

    hi,I have question if I used this way , is my program has more safe?

  • vvidhu1988

    hi i have a question. Let say there is class A and Class B

    Class A {
    int value,
    B bMember,

    Public:
    A() {
    value = 0;
    }
    };

    here when i create an object to Class A say

    A aMember;

    Is the constructor of class A is called and initializes ‘value’ to 0 or before calling Class A’s constructor, whether Calss B’s constructor will be called? since we also have object(bmember) of class type B.

    Please explain when class B’s constructor will be called.

    Whether in the above code i need to initialize ‘bMember’ of class type B in the Class A’s constructor?? since bMember is also a member in class A. I don’t think it is a proper implementation. Can anyone explain?

    • Nikhil Singhal

      Hi,

      The Ans is Very Simple……

      B constructor first called, because first declaration part is done then A’s Constructor is called, so here B’s object is created first.
      I think you got the answer
      if have any confusion run the following code in debug mode:

      class B {
      int BValue;
      public:
      B()
      {
      BValue = 0;
      printf(“\n Class B Constructor is Called”);
      }
      };
      class A {
      int value;
      B bMember;

      public:
      A()
      {
      value = 0;
      printf(“\n Class A Constructor is Called \n “);
      }
      };

      int main(int argc, char* argv[])
      {
      A a1;
      return 0;
      }

  • MrPlow442

    One question.

    Do i have to use body brackets {}?
    Can’t i just write?
    Something() : m_nValue(0), m_dValue(0.0), m_pnValue(0) ; ?

  • MK

    Hi Alex.
    thank you for your epic tutorial.

    small typo.

    “When the class’s constructor is executed, m_nValue, m_dValue, and m_chValue are created.”

    “m_chValue” should be “m_pnValue”

  • [...] the previous lesson on initializer lists, you learned that the preferred way to initialize class members is through initializer lists rather [...]

You must be logged in to post a comment.