What are the rules for calling the base class constructor?

Base class constructors are automatically called for you if they have no argument. If you want to call a superclass constructor with an argument, you must use the subclass's constructor initialization list. Unlike Java, C++ supports multiple inheritance (for better or worse), so the base class must be referred to by name, rather than "super()".

class SuperClass

{

    public:



        SuperClass(int foo)

        {

            // do something with foo

        }

};



class SubClass : public SuperClass

{

    public:



        SubClass(int foo, int bar)

        : SuperClass(foo)    // Call the superclass constructor in the subclass' initialization list.

        {

            // do something with bar

        }

};

4 years ago

In C++, the no-argument constructors for all superclasses and member variables are called for you, before entering your constructor. If you want to pass them arguments, there is a separate syntax for this called "constructor chaining", which looks like this:

class Sub : public Base

{

  Sub(int x, int y)

  : Base(x), member(y)

  {

  }

  Type member;

};

If anything run at this point throws, the bases/members which had previously completed construction have their destructors called and the exception is rethrown to to the caller. If you want to catch exceptions during chaining, you must use a function try block:

class Sub : public Base

{

  Sub(int x, int y)

  try : Base(x), member(y)

  {

    // function body goes here

  } catch(const ExceptionType &e) {

    throw kaboom();

  }

  Type member;

};

In this form, note that the try block is the body of the function, rather than being inside the body of the function; this allows it to catch exceptions thrown by implicit or explicit member and base class initializations, as well as during the body of the function. However, if a function catch block does not throw a different exception, the runtime will rethrow the original error; exceptions during initialization cannot be ignored.

4 years ago