• 1Explanation
  • 1.1In namespace and block scope
  • 1.2In class definition
  • 1.3Inheriting constructors
  • 1.4Introducing scoped enumerators
• 2Notes
• 3Keywords
• 4Defect reports
• 5References

A using-declaration with more than one using-declarator is equivalent to a corresponding sequence of using-declarations with one using-declarator.

Inheriting constructors

If theusing-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.

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 theBase subobject from which the constructor was inherited is initialized using the inherited constructor, and all other bases and members ofDerived 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 issequenced 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

struct W{ W(int);}; struct X:virtual W{using W::W;// inherits W(int)    X()= delete;}; struct Y: X{using X::X;}; struct Z: Y,virtual W{using Y::Y;}; Z z(0);// OK: initialization of Y does not invoke default constructor of X

If theBase base class subobject is not to be initialized as part of theDerived object (i.e.,Base is avirtual base class ofDerived, and theDerived object is not themost derived object), the invocation of the inherited constructor, including the evaluation of any arguments, is omitted:

struct V{    V()=default;    V(int);}; struct Q{ Q();}; struct A:virtual V, Q{using V::V;    A()= delete;}; int bar(){return42;} struct B: A{    B(): A(bar()){}// OK}; struct C: B{}; void foo(){    C c;// “bar” is not invoked, because the V subobject// is not initialized as part of B// (the V subobject is initialized as part of C,//  because “c” is the most derived object)}

If the constructor was inherited from multiple base class subobjects of typeBase, the program is ill-formed, similar to multiply-inherited non-static member functions:

struct A{ A(int);};struct B: A{using A::A;};struct C1: B{using B::B;};struct C2: B{using B::B;}; struct D1: C1, C2{using C1::C1;using C2::C2;};D1 d1(0);// ill-formed: constructor inherited from different B base subobjects struct V1:virtual B{using B::B;};struct V2:virtual B{using B::B;}; struct D2: V1, V2{using V1::V1;using V2::V2;};D2 d2(0);// OK: there is only one B subobject.// This initializes the virtual B base class,//   which initializes the A base class// then initializes the V1 and V2 base classes//   as if by a defaulted default constructor

As with using-declarations for any other non-static member functions, if an inherited constructor matches the signature of one of the constructors ofDerived, it is hidden from lookup by the version found inDerived. If one of the inherited constructors ofBase happens to have the signature that matches a copy/move constructor of theDerived, it does not prevent implicit generation ofDerived copy/move constructor (which then hides the inherited version, similar tousing operator=).

struct B1{ B1(int);};struct B2{ B2(int);}; struct D2: B1, B2{using B1::B1;using B2::B2;     D2(int);// OK: D2::D2(int) hides both B1::B1(int) and B2::B2(int)};D2 d2(0);// calls D2::D2(int)

Within atemplated class, if a using-declaration refers to adependent name, it is considered to name a constructor if thenested-name-specifier has a terminal name that is the same as theunqualified-id.

template<class T>struct A: T{using T::T;// OK, inherits constructors of T}; template<class T,class U>struct B: T, A<U>{using A<U>::A;// OK, inherits constructors of A<U>using T::A;// does not inherit constructor of T// even though T may be a specialization of A<>};

Introducing scoped enumerators

In addition to members of another namespace and members of base classes, using-declaration can also introduce enumerators ofenumerations into namespace, block, and class scopes.

A using-declaration can also be used with unscoped enumerators.

enumclass button{ up, down}; struct S{using button::up;    button b= up;// OK}; using button::down;constexpr button non_up= down;// OK constexprauto get_button(bool is_up){using button::up, button::down;return is_up? up: down;// OK} enum unscoped{ val};using unscoped::val;// OK, though needless

The semantics of inheriting constructors were retroactively changed by adefect report against C++11. Previously, an inheriting constructor declaration caused a set of synthesized constructor declarations to be injected into the derived class, which caused redundant argument copies/moves, had problematic interactions with some forms of SFINAE, and in some cases can be unimplementable on major ABIs. Older compilers may still implement the previous semantics.

struct B1{    B1(int);}; struct D1: B1{using B1::B1; // The set of candidate inherited constructors is// 1. B1(const B1&)// 2. B1(B1&&)// 3. B1(int) // D1 has the following constructors:// 1. D1() = delete// 2. D1(const D1&)// 3. D1(D1&&)// 4. D1(int) <- inherited}; struct B2{    B2(int=13,int=42);}; struct D2: B2{using B2::B2; // The set of candidate inherited constructors is// 1. B2(const B2&)// 2. B2(B2&&)// 3. B2(int = 13, int = 42)// 4. B2(int = 13)// 5. B2() // D2 has the following constructors:// 1. D2()// 2. D2(const D2&)// 3. D2(D2&&)// 4. D2(int, int) <- inherited// 5. D2(int) <- inherited};

Pack expansions in using-declarations make it possible to form a class that exposes overloaded members of variadic bases without recursion:

template<typename...Ts>struct Overloader: Ts...{using Ts::operator()...;// exposes operator() from every base}; template<typename...T>Overloader(T...)-> Overloader<T...>;// C++17 deduction guide, not needed in C++20 int main(){auto o= Overloader{[](autoconst& a){std::cout<< a;},[](float f){std::cout<<std::setprecision(3)<< f;}};}