What is constructor inheritance?

by

Inheriting Constructors means just that. A derived class can implicitly inherit constructors from its base class(es).

The syntax is as follows:

struct B
{
    B(int); // normal constructor 1
    B(string); // normal constructor 2
};

struct D : B
{
    using B::B; // inherit constructors from B
};

So now D has the following constructors implicitly defined:

D::D(int); // inherited
D::D(string); // inherited

Ds members are default constructed by these inherited constructors.

It is as though the constructors were defined as follows:

D::D(int x) : B(x) {}
D::D(string s) : B(s) {}

The feature isn’t anything special. It is just a shorthand to save typing boilerplate code.

Here are the gory details:

12.9 Inheriting Constructors

1) A using-declaration that names a constructor implicitly declares a
set of inheriting constructors. The candidate set of inherited
constructors from the class X named in the using-declaration consists
of actual constructors and notional constructors that result from the
transformation of defaulted parameters as follows:

  • all non-template constructors of X, and
  • for each non-template constructor of X that has at least one parameter with a default argument, the set of constructors that
    results from omitting any ellipsis parameter specification and
    successively omitting parameters with a default argument from the end
    of the parameter-type-list, and
  • all constructor templates of X, and
  • for each constructor template of X that has at least one parameter with a default argument, the set of constructor templates that results
    from omitting any ellipsis parameter specification and successively
    omitting parameters with a default argument from the end of the
    parameter-type-list

More Related Contents:

  1. Using C++ base class constructors?
  2. Rule-of-Three becomes Rule-of-Five with C++11? [closed]
  3. What are the rules for calling the base class constructor?
  4. Inheriting constructors
  5. How to use base class’s constructors and assignment operator in C++?
  6. Initialize parent’s protected members with initialization list (C++)
  7. Copy constructor is not inherited
  8. Do I really need to implement user-provided constructor for const objects?
  9. Calling the base class constructor from the derived class constructor
  10. How to use sfinae for selecting constructors?
  11. Is a `=default` move constructor equivalent to a member-wise move constructor?
  12. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  13. Forwarding all constructors in C++0x
  14. Has the new C++11 member initialization feature at declaration made initialization lists obsolete?
  15. Different ways of initializing an object in c++
  16. Why not to inherit from std::allocator
  17. What’s the point of a final virtual function?
  18. C++11 anonymous union with non-trivial members
  19. C++11 virtual destructors and auto generation of move special functions
  20. Class inherited from class without default constructor
  21. Conflict between copy constructor and forwarding constructor
  22. Why the initializer of std::function has to be CopyConstructible?
  23. Default member values best practice
  24. C++ Constructor/Destructor inheritance
  25. How to change mode from c++98 mode in Dev-C++ to a mode that supports C++0x (range based for)?
  26. Using regex lookbehinds in C++11
  27. Check at Compile-Time if Template Argument is void
  28. error::make_unique is not a member of ‘std’
  29. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  30. Concatenate compile-time strings in a template at compile time?

Leave a Comment