Inheriting Constructors in C++

If a using-declaration refers to a constructor of a direct base of the class being defined (e.g. using Base::Base;), all constructors of that base (ignoring member access) are made visible to overload resolution when initializing the derived class.

This is a powerful technique for deriving from classes with a rich set of constructors, such as STL containers. Look at this:

class MyString : public std::string {
  // ..
  using std::string::string;
  // ...
      

If overload resolution selects an inherited constructor, it is accessible if it would be accessible when used to construct an object of the corresponding base class: the accessibility of the using-declaration that introduced it is ignored.

If overload resolution selects one of the inherited constructors when initializing an object of such derived class, then the Base subobject from which the constructor was inherited is initialized using the inherited constructor, and all other bases and members of Derived are initialized as if by the defaulted default constructor (default member initializers are used if provided, otherwise default initialization takes place). The entire initialization is treated as a single function call: initialization of the parameters of the inherited constructor is sequenced before initialization of any base or member of the derived object.

struct B1 { B1(int, ...) {} };
struct B2 { B2(double)   {} };

int get();

struct D1 : B1
{
  using B1::B1; // inherits B1(int, ...)
  int x;
  int y = get();
};

void test()
{
  D1 d(2, 3, 4); // OK: B1 is initialized by calling B1(2, 3, 4),
                 // then d.x is default-initialized (no initialization is performed),
                 // then d.y is initialized by calling get()

  D1 e;          // Error: D1 has no default constructor
}

struct D2 : B2
{
  using B2::B2; // inherits B2(double)
  B1 b;
};

D2 f(1.0); // error: B1 has no default constructor