Объявление 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-объявление относится к зависимому имени, оно считается именем конструктора, если спецификатор_вложенного_имени имеет конечное имя, которое такое же, как неквалифицированный_идентификатор.

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, а в некоторых случаях было нереализуемо на основных ABIs. Более старые компиляторы могут по-прежнему реализовывать предыдущие семантики.

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