Using-declaration

Объявление 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; // наследует B1(int, ...)
    int x;
    int y = get();
};
void test()
{
    D1 d(2, 3, 4); // OK: B1 инициализируется вызовом B1(2, 3, 4),
                   // затем d.x инициализируется по умолчанию (инициализация не выполняется),
                   // затем d.y инициализируется вызовом get()
    D1 e;          // Ошибка: D1 не имеет конструктора по умолчанию
}
struct D2 : B2
{
    using B2::B2; // наследует B2(double)
    B1 b;
};
D2 f(1.0); // ошибка: B1 не имеет конструктора по умолчанию

struct W { W(int); };
struct X : virtual W
{
    using W::W; // наследует W(int)
    X() = delete;
};
struct Y : X
{
    using X::X;
};
struct Z : Y, virtual W
{
    using Y::Y;
};
Z z(0); // OK: инициализация Y не вызывает конструктор по умолчанию 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" не вызывается, потому что подобъект V
         // не инициализируется как часть B
         // (подобъект V инициализируется как часть C,
         //  потому что "c" является наиболее производным объектом)
}

Если конструктор был унаследован от нескольких базовых подобъектов типа 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); // некорректно: конструктор унаследован от разных базовых подобъектов B
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); // корректно: существует только один подобъект B.
          // Это инициализирует виртуальный базовый класс B,
          //   который инициализирует базовый класс A
          // затем инициализирует базовые классы V1 и V2
          //   как если бы конструктором по умолчанию

Как и в случае с 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) скрывает как B1::B1(int), так и B2::B2(int)
};
D2 d2(0);    // вызывает D2::D2(int)

Внутри шаблонного класса , если using-объявление ссылается на зависимое имя , оно считается именующим конструктор, если nested-name-specifier имеет терминальное имя, совпадающее с unqualified-id .

template<class T>
struct A : T
{
    using T::T; // OK, наследует конструкторы T
};
template<class T, class U>
struct B : T, A<U>
{
    using A<U>::A; // OK, наследует конструкторы A<U>
    using T::A;    // не наследует конструктор T
                   // даже если T может быть специализацией 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
};

Pack expansions в 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;} };
}