Question

I have a base class that declares and defines a constructor, but for some reason my publicly derived class is not seeing that constructor, and I therefore have to explicitly declare a forwarding constructor in the derived class:

class WireCount0 {
protected:
    int m;
public:
    WireCount0(const int& rhs) { m = rhs; }
};

class WireCount1 : public WireCount0 {};

class WireCount2 : public WireCount0 {
public: 
  WireCount2(const int& rhs) : WireCount0(rhs) {}
};

int dummy(int argc, char* argv[]) {
    WireCount0 wireCount0(100);
    WireCount1 wireCount1(100);
    WireCount2 wireCount2(100);
    return 0;
}

In the above code, my WireCount1 wireCount1(100) declaration is rejected by the compiler (“No matching function for call to ‘WireCount1::WireCount1(int)'”), while my wireCount0 and wireCount2 declarations are fine.

I’m not sure that I understand why I need to provide the explicit constructor shown in WireCount2. Is it because the compiler generates a default constructor for WireCount1, and that constructor hides the WireCount0 constructor?

For reference, the compiler is i686-apple-darwin10-gcc-4.2.1 (GCC) 4.2.1 (Apple Inc. build 5659).

Answer 1

All the derived classes must call their base class’s constructor in some shape or form.

When you create an overloaded constructor, your default compiler generated parameterless constructor disappears and the derived classes must call the overloaded constructor.

When you have something like this:

class Class0 {
}

class Class1 : public Class0 {
}

The compiler actually generates this:

class Class0 {
public:
  Class0(){}
}

class Class1 : public Class0 {
  Class1() : Class0(){}
}

When you have non-default constructor, the parameterless constructor is no longer generated. When you define the following:

class Class0 {
public:
  Class0(int param){}
}

class Class1 : public Class0 {
}

The compiler no longer generates a constructor in Class1 to call the base class’s constructor, you must explicitly do that yourself.