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)
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 /* */ }; 
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.
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
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) { } How about using a template function to bind all constructors?
template <class... T> Derived(T... t) : Base(t...) {} 
Derived's copy constructor.
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.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
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.
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; } 