Inheriting constructors

Question

Why does this code:

class A
{
 public: 
 explicit A(int x) {}
};
class B: public A
{
};
int main(void)
{
 B *b = new B(5);
 delete b;
}

Result in these errors:

main.cpp: In function ‘int main()’:
main.cpp:13: error: no matching function for call to ‘B::B(int)’
main.cpp:8: note: candidates are: B::B()
main.cpp:8: note: B::B(const B&)

Shouldn't B inherit A's constructor?

(this is using gcc)

Answer 1

If your compiler supports C++11 standard, there is a constructor inheritance using using (pun intended). For more see Wikipedia C++11 article. You write:

class A
{
 public: 
 explicit A(int x) {}
};
class B: public A
{
 using A::A;
};

This is all or nothing - you cannot inherit only some constructors, if you write this, you inherit all of them. To inherit only selected ones you need to write the individual constructors manually and call the base constructor as needed from them.

Historically constructors could not be inherited in the C++03 standard. You needed to inherit them manually one by one by calling base implementation on your own.

---

For templated base classes, refer to this example:

using std::vector;
 
template<class T>
class my_vector : public vector<T> {
 public:
 using vector<T>::vector; ///Takes all vector's constructors
 /* */
};

• Mikhail: This is quite evil because for over a year that has been no compiler that can actually build the above code :-)
• Jan Korous: @Mikhail: Both clang and g++ should now support inheriting constructors: clang.llvm.org/cxx_status.html gcc.gnu.org/projects/cxx0x.html Recommend upvoting this one as the correct answer.
• geometrian: I am a person from the future! MSVC 2015 claims support.
• whoKnows: Can you use this syntax to only inherit a specific constructor?
• boycy: @whoKnows: No, this is all-or-nothing: en.cppreference.com/w/cpp/language/using_declaration

Answer 2

Constructors are not inherited. They are called implicitly or explicitly by the child constructor.

The compiler creates a default constructor (one with no arguments) and a default copy constructor (one with an argument which is a reference to the same type). But if you want a constructor that will accept an int, you have to define it explicitly.

class A
{
public: 
 explicit A(int x) {}
};
class B: public A
{
public:
 explicit B(int x) : A(x) { }
};

UPDATE: In C++11, constructors can be inherited. See Suma's answer for details.

Answer 3

This is straight from Bjarne Stroustrup's page:

If you so choose, you can still shoot yourself in the foot by inheriting constructors in a derived class in which you define new member variables needing initialization:

struct B1 {
 B1(int) { }
};
struct D1 : B1 {
 using B1::B1; // implicitly declares D1(int)
 int x;
};
void test()
{
 D1 d(6); // Oops: d.x is not initialized
 D1 e; // error: D1 has no default constructor
}

note that using another great C++11 feature (member initialization):

 int x = 77;

instead of

int x;

would solve the issue

• HelpingHand: In general, I wouldn't consider inheriting base class ctors as shooting yourself in the foot, but good practice - in those cases where this is possible. The cases where this is is possible are the ones where the subclass does not add members that require construction. However, if one modifies the subclass later and adds members that require initialization in the constructor, one has to change the constructor, too - and replace the inheritance by a custom constructor. If one forgets this when adding the subclass members, one shoots into the foot as if not updating a custom ctor.
• user13947194: Why is this an answer? How comes it has upvotes. Shows you that StackOverflow is not as fair. Shouldnt this be a comment?

Answer 4

You have to explicitly define the constructor in B and explicitly call the constructor for the parent.

B(int x) : A(x) { }

or

B() : A(5) { }

• HelpingHand: No - as of C++11, you don't have to any more.

Answer 5

How about using a template function to bind all constructors?

template <class... T> Derived(T... t) : Base(t...) {}

• Maxim Ky: Probably you should do it with perfect forwarding: template < typename ... Args > B( Args && ... args ) : A( std::forward< Args >( args ) ... ) {}
• Barry: And you just broke Derived's copy constructor.
• Zebrafish: Would Base's constructor have to be templated too? When you call Base(t...), then Base would have to be templated for whatever t is?
• MSalters: @Zebrafish: No, it doesn't. And even if it was, it wouldn't have to be templated in the same way. This is because when the Derived ctor is instantiated, it calls a Base ctor. This base ctor call is subject to the usual overload resolution given the (instantiated) arguments t.... That's why there is a warning about the copy ctor: this will blindly try to call Base::Base(Derived const& src), which could very well slice the Base part of src.

Answer 6

Correct Code is

class A
{
 public: 
 explicit A(int x) {}
};
class B: public A
{
 public:
 B(int a):A(a){
 }
};
main()
{
 B *b = new B(5);
 delete b;
}

Error is b/c Class B has not parameter constructor and second it should have base class initializer to call the constructor of Base Class parameter constructor

Answer 7

Starting from C++17, in certain circumstances, it may appear that the constructor is inherited.

The following is legal:

struct A {
 A(int x): x(x) {}
 int x;
};
struct B: public A{
};
int main(){
 B b {1};
}

Even though B does not have using A::A;, you can construct B b {1}; without any issue.

The reason is not automatic constructor inheritance. Look at the following:

struct A {
 A(int x, int y): x(x), y(y) {}
 int x, y;
};
struct B: public A{
};
int main(){
 //B b {1, 2}; // error, would have worked with `using A::A;`
 B b {{1, 2}}; // works, would error with `using A::A;`
}

The reason is, starting from C++17, struct B above is considered an aggregate. So it behaves similar to the following:

struct A {
 A(int x): x(x) {}
 int x;
};
struct B {
 A base;
};
int main(){
 B b {1}; // also valid in C++14, since struct B above is aggregate either way
}

Starting from C++20, you can even use parentheses:

#include <vector>
struct A {
 A(int x): x(x) {}
 int x;
};
struct B: public A{
};
int main(){
 B b (1); // illegal in C++17, legal in C++20
 B d (int()); // most vexing parse! I recommend using braces, although in emplace_back() you have no choice
 B e {int()}; // int() = 0, fine
 std::vector<B> v;
 v.emplace_back(1); // illegal in C++17, legal in C++20
}

Credit: Automatic constructor inheritance in C++20 and linked questions.

Answer 8

derived class inherits all the members(fields and methods) of the base class, but derived class cannot inherit the constructor of the base class because the constructors are not the members of the class. Instead of inheriting the constructors by the derived class, it only allowed to invoke the constructor of the base class

class A
{
 public: 
 explicit A(int x) {}
};
class B: public A
{
 B(int x):A(x);
};
int main(void)
{
 B *b = new B(5);
 delete b;
}