Using-declaration

Una declaración using con más de un using-declarator es equivalente a una secuencia correspondiente de declaraciones using con un using-declarator.

Herencia de constructores

Si la using-declaration se refiere a un constructor de una base directa de la clase que se está definiendo (por ejemplo using Base :: Base ; ), todos los constructores de esa base (ignorando el acceso de miembro) se hacen visibles para la resolución de sobrecarga al inicializar la clase derivada.

Si la resolución de sobrecarga selecciona un constructor heredado, es accesible si sería accesible cuando se utiliza para construir un objeto de la clase base correspondiente: se ignora la accesibilidad de la declaración using que lo introdujo.

Si la resolución de sobrecarga selecciona uno de los constructores heredados al inicializar un objeto de dicha clase derivada, entonces el Base subobjeto del cual se heredó el constructor se inicializa utilizando el constructor heredado, y todas las demás bases y miembros de Derived se inicializan como si fuera por el constructor predeterminado por defecto (se utilizan los inicializadores de miembros predeterminados si se proporcionan, de lo contrario tiene lugar la inicialización predeterminada). Toda la inicialización se trata como una única llamada de función: la inicialización de los parámetros del constructor heredado está secuenciada antes de la inicialización de cualquier base o miembro del objeto derivado.

struct B1 { B1(int, ...) {} };
struct B2 { B2(double)   {} };
int get();
struct D1 : B1
{
    using B1::B1; // hereda B1(int, ...)
    int x;
    int y = get();
};
void test()
{
    D1 d(2, 3, 4); // OK: B1 se inicializa llamando a B1(2, 3, 4),
                   // luego d.x se inicializa por defecto (no se realiza inicialización),
                   // luego d.y se inicializa llamando a get()
    D1 e;          // Error: D1 no tiene constructor por defecto
}
struct D2 : B2
{
    using B2::B2; // hereda B2(double)
    B1 b;
};
D2 f(1.0); // error: B1 no tiene constructor por defecto

struct W { W(int); };
struct X : virtual W
{
    using W::W; // hereda W(int)
    X() = delete;
};
struct Y : X
{
    using X::X;
};
struct Z : Y, virtual W
{
    using Y::Y;
};
Z z(0); // OK: la inicialización de Y no invoca el constructor por defecto de X

Si el subobjeto de la clase base Base no va a ser inicializado como parte del objeto Derived (es decir, Base es una clase base virtual de Derived , y el objeto Derived no es el objeto más derivado ), se omite la invocación del constructor heredado, incluyendo la evaluación de cualquier argumento:

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()) {} // CORRECTO
};
struct C : B {};
void foo()
{
    C c; // "bar" no se invoca, porque el subobjeto V
         // no se inicializa como parte de B
         // (el subobjeto V se inicializa como parte de C,
         //  porque "c" es el objeto más derivado)
}

Si el constructor fue heredado de múltiples subobjetos de clase base de tipo Base , el programa está mal formado, similar a las funciones miembro no estáticas heredadas múltiples veces:

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); // mal formado: constructor heredado de diferentes subobjetos base 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); // correcto: solo hay un subobjeto B.
          // Esto inicializa la clase base virtual B,
          //   que inicializa la clase base A
          // luego inicializa las clases base V1 y V2
          //   como si fuera por un constructor por defecto predeterminado

Al igual que con las declaraciones using para cualquier otra función miembro no estática, si un constructor heredado coincide con la firma de uno de los constructores de Derived , queda oculto de la búsqueda por la versión encontrada en Derived . Si uno de los constructores heredados de Base coincide por casualidad con la firma de un constructor de copia/movimiento de Derived , no impide la generación implícita del constructor de copia/movimiento de Derived (que luego oculta la versión heredada, similar a 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) oculta tanto B1::B1(int) como B2::B2(int)
};
D2 d2(0);    // llama a D2::D2(int)

Dentro de una clase plantilla , si una declaración using se refiere a un nombre dependiente , se considera que nombra un constructor si el nested-name-specifier tiene un nombre terminal que es el mismo que el unqualified-id .

template<class T>
struct A : T
{
    using T::T; // OK, hereda los constructores de T
};
template<class T, class U>
struct B : T, A<U>
{
    using A<U>::A; // OK, hereda los constructores de A<U>
    using T::A;    // no hereda el constructor de T
                   // aunque T puede ser una especialización de A<>
};

Introducción de enumeradores con ámbito

Además de los miembros de otro espacio de nombres y los miembros de clases base, la declaración using también puede introducir enumeradores de enumeraciones en ámbitos de espacio de nombres, bloque y clase.

Una declaración using también puede usarse con enumeradores sin ámbito.

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

La semántica de los constructores heredados fue modificada retroactivamente por un informe de defectos contra C++11 . Anteriormente, una declaración de constructor heredado causaba que un conjunto de declaraciones de constructores sintetizados se inyectaran en la clase derivada, lo que provocaba copias/movimientos redundantes de argumentos, tenía interacciones problemáticas con algunas formas de SFINAE, y en algunos casos podía ser no implementable en ABIs principales. Los compiladores más antiguos aún pueden implementar la semántica anterior.

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

Las expansiones de paquetes en las declaraciones using permiten formar una clase que expone miembros sobrecargados de bases variádicas sin recursión:

template<typename... Ts>
struct Overloader : Ts...
{
    using Ts::operator()...; // expone operator() de cada base
};
template<typename... T>
Overloader(T...) -> Overloader<T...>; // guía de deducción C++17, no necesaria en C++20
int main()
{
    auto o = Overloader{ [] (auto const& a) {std::cout << a;},
                         [] (float f) {std::cout << std::setprecision(3) << f;} };
}