Объявление using

Объявление using с несколькими using-деклараторами эквивалентно соответствующей последовательности объявлений using, каждое из которых содержит один using-декларатор.

Наследование конструкторов

Если объявление using ссылается на конструктор прямого базового класса определяемого класса (например, using Base::Base;), все конструкторы этого базового класса (без учёта доступа к членам) становятся видимыми для разрешения перегрузки при инициализации производного класса.

Если при разрешении перегрузки выбран унаследованный конструктор, к нему есть доступ, если бы к нему был доступ при создании объекта соответствующего базового класса: доступность объявления using, которое его ввело, не учитывается.

Если при инициализации объекта такого производного класса при разрешении перегрузки выбран один из унаследованных конструкторов, подобъект Base, от которого был унаследован конструктор, инициализируется с помощью унаследованного конструктора, а все остальные базовые классы и члены Derived инициализируются так, как если бы это выполнял конструктор по умолчанию, сгенерированный по умолчанию (если заданы инициализаторы членов по умолчанию, используются они, иначе выполняется инициализация по умолчанию). Вся инициализация рассматривается как один вызов функции: инициализация параметров унаследованного конструктора упорядочена перед инициализацией любого базового класса или члена производного объекта.

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

Если подобъект базового класса Base не должен инициализироваться как часть объекта Derived (т. е. Base является виртуальным базовым классом для Derived, а объект Derived не является наиболее производным объектом), вызов унаследованного конструктора, включая вычисление любых аргументов, опускается:

struct V
{
    V() = default;
    V(int);
};

struct Q { Q(); };

struct A : virtual V, Q
{
    using V::V;
    A() = delete;
};

int bar() { return 42; }

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)
}

Если конструктор унаследован от нескольких подобъектов базового класса типа Base, программа некорректна, как и в случае множественного наследования функций-членов, не являющихся статическими:

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

Как и в случае объявлений using для любых других нестатических функций-членов, если унаследованный конструктор соответствует сигнатуре одного из конструкторов Derived, он скрывается при поиске версией, найденной в Derived. Если один из унаследованных конструкторов Base имеет сигнатуру, совпадающую с конструктором копирования/перемещения Derived, это не препятствует неявной генерации конструктора копирования/перемещения Derived (который затем скрывает унаследованную версию, как и в случае using 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)

Внутри шаблонного класса, если объявление using ссылается на зависимое имя, оно считается обозначающим конструктор, если конечное имя в nested-name-specifier совпадает с unqualified-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<>
};

Введение перечислителей с областью видимости

Помимо членов другого пространства имён и членов базовых классов, объявление using также может вводить перечислители перечислений в пространства имён и области видимости блока и класса.

Объявление using также можно использовать с перечислителями без области видимости.

enum class button { up, down };

struct S
{
    using button::up;
    button b = up; // OK
};

using button::down;
constexpr button non_up = down; // OK

constexpr auto 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

Семантика наследования конструкторов была изменена задним числом в соответствии с отчётом об ошибке для C++11. Ранее объявление наследуемого конструктора приводило к внедрению в производный класс набора синтезированных объявлений конструкторов, что вызывало избыточное копирование/перемещение аргументов, проблемное взаимодействие с некоторыми формами SFINAE, а в некоторых случаях было невозможно реализовать в основных ABI. Старые компиляторы всё ещё могут реализовывать прежнюю семантику.

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
};

Раскрытия пакетов в объявлениях using позволяют создавать класс, предоставляющий перегруженные члены вариативных базовых классов без рекурсии:

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{ [] (auto const& a) {std::cout << a;},
                         [] (float f) {std::cout << std::setprecision(3) << f;} };
}