What are the rules for calling the base class constructor?

Question

What are the C++ rules for calling the base class constructor from a derived class?

For example, I know in Java, you must do it as the first line of the subclass constructor (and if you don't, an implicit call to a no-arg super constructor is assumed - giving you a compile error if that's missing).

Answer 1

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         } }; 

More info on the constructor's initialization list here and here.

Answer 2

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.