Do we "inherit" constructors in C++ ? What's is exact definition of "inheriting"

Question

I wonder why people say:

"Inheriting class doesn't inherit the constructor".

If you could CAN use the parent class' constructor, and the parameterless constructor are called automatically no matter what.

Example:

#include <iostream>
using namespace std;

class A {
    private :
        int x;
    public  :
        A () {
            cout << "I anyway use parameter-less constructors, they are called always" << endl;
        }
        A (const int& x) {
            this->x = x;
            cout << "I can use the parent constructor" << endl;
        }
};

class B : public A {
    private :
        int y;
    public  :
        B() {

        }
        B (const int& x, const int& y) : A (x) {
            this->y = y;
        }
};

int main() {

    B* b  = new B(1,2);
    B* b1 = new B();
    return 0;
}

http://ideone.com/e.js/6jzkiP

So is it correct to 'say', constructors are inherited in c++ ? What is exact definition of "inherit" in programming languages ?

Thanks in advance.

Answer 1

I wonder why people say: "Inheriting class doesn't inherit the constructor".

Perhaps it is best to illustrate this with an example:

struct Foo
{
  Foo(int, int) {}
};

struct Bar : Foo
{
};

What it means is that there is no Bar::Bar(int, int) constructor that you can call, despite the existence of a constructor with the same parameter list in the base class. So you cannot do this:

Bar b(42, 42);

In C++11, you can actually inherit constructors, but you must be explicit about it:

struct Bar : Foo
{
  using Foo::Foo;
};

Now, you can say Bar b(42, 42);

Answer 2

What they mean is that constructor signatures are not inherited.

In your example, B does not have a constructor taking a single const int& even though its base class does. In this sense it has not "inherited" the constructor (but can still make use of it).

Answer 3

I think what they mean is:

struct A {
    A(int, int) { }
};

struct B : public A {
};

int main()
{
    A a(1, 2); // ok
    B b(1, 2); // error
}

To compare with “non-special” member functions:

struct A {
    void f() { }
};

struct B : public A {
};

int main()
{
    A a;
    B b;
    a.f(); // ok
    b.f(); // ok too
}

But of course, from within B you can call accessible A constructors (as automatically generated ones do). Ditto for the destructor.

---

Note that in C++11 you can use the “inheriting constructors” feature:

struct A {
    A(int, int) { }
};

struct B : public A {
    using A::A;
};

int main()
{
    A a(1, 2); // ok
    B b(1, 2); // ok now
}