Declaración using

Una declaración using con más de un declarador using es equivalente a la secuencia correspondiente de declaraciones using con un declarador using.

Heredar constructores

Si la declaración using se refiere a un constructor de una base directa de la clase que se define (p. ej., using Base::Base;), todos los constructores de esa base (ignorando acceso de miembros) se hacen visibles para la resolución de sobrecarga cuando se inicialice la clase derivada.

Si la resolución de sobrecarga selecciona un constructor heredado, es accesible si hubiera sido accesible cuando se usó para construir un objeto de la clase base correspondiente: se ignora la accesibilidad de la declaración using que la introdujo.

Si la resolución de sobrecarga selecciona uno de los constructores heredados al inicializar un objeto de tal clase derivada, entonces el subobjeto Base subobject del cual se heredó el constructor, se inicializa usando el constructor heredado, y todos las otras bases y miembros de Derivada se inicializan como si se hubiera invocado el constructor por defecto (si se suministraron, se usan los inicializadores por defecto de los miembros, de otra manera la inicialización por defecto tiene lugar). Toda la inicialización se trata como una sola llamada de función: la inicialización de los parámetros del constructor heredado está secuenciado-antes que 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 a B1(int, ...)
  int x;
  int y = get();
};
 
void test() 
{
  D1 d(2, 3, 4); // de acuerdo: B1 se inicializa llamando a B1(2, 3, 4),
                 // entonces d.x se inicializa por defecto (no se ejecuta 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 a 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 a W(int)
    X() = delete;
};
 
struct Y : X 
{
    using X::X;
};
 
struct Z : Y, virtual W 
{
    using Y::Y;
};
 
Z z(0); // de acuerdo: la inicialización de Y no invoca al constructor por defecto de X

Si el constructor se heredó de múltiples subobjetos de clases base de tipo B, el programa está mal formado, similar a 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 de 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); // de acuerdo: 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 marcado con = default

Similar a las declaraciones using para cualquier otra función miembro no estática, si el constructor heredado coincide con la signatura de uno de los constructores de Derivada, se esconde de la búsqueda por la versión encontrada en Derivada. Si sucede que uno de los contructores heredados de Base tiene la signatura que coincide con el constructor de copia/movimiento de Derivada, no se previene la generación implícita del constructor de copia/movimiento de Derivada (que a su vez esconde 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);   // de acuerdo: D2::D2(int) esconde ambos: B1::B1(int) y B2::B2(int)
};
 
D2 d2(0);    // llama a D2::D2(int)

Dentro de una clase con plantilla, si una declaración using se refiere a un nombre dependiente, se considera que nombra a un constructor si el especificador-de-nombre-anidado tiene un nombre terminal que es mismo que el id-no-calificado.

template<class T>
struct A : T
{
    using T::T; // Correcto, hereda constructores de T
};
 
template<class T, class U>
struct B : T, A<U>
{
    using A<U>::A; // Correcto, hereda 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 de ámbito

Como añadido a miembros de otro espacio de nombre y de clases base, la declaración using también puede introducir enumeradores de enumeraciones en los ámbitos de un espacio de nombres, bloque y clase.

También se puede usar una declaración using con enumeradores sin ámbito.

enum class boton { arriba, abajo };
 
struct S
{
    using boton::arriba;
    boton b = arriba; // correcto
};
 
using boton::abajo;
constexpr boton no_arriba = abajo; // correcto
 
constexpr auto obtener_boton(bool esta_arriba)
{
    using boton::arriba, boton::abajo;
    return esta_arriba ? arriba : abajo; // correcto
}
 
enum sinambito { val };
using sinambito::val; // correcto, aunque innecesario

La semántica de la herencia de constructores se cambió retroactivamente por un informe de defecto de C++11. Previamente, una declaración de constructor heredado ocasionaba que se inyectara un conjunto de declaraciones de constructor sintetizadas en la clase derivada, que a su vez ocasionaba copias/movimientos redundantes de argumentos, tenía interacciones problemáticas con algunas formas de SFINAE, y en algunos casos puede no ser implementable en ABIs importantes. Los compiladores más antiguos pueden todavía implementar la semántica previa.

struct B1 
{
    B1(int);
};
 
struct D1 : B1 
{
    using B1::B1;
    // El conjunto de constructores candidatos heredados es
    // 1. B1(const B1&)
    // 2. B1(B1&&)
    // 3. B1(int)
 
    // D1 tiene los siguientes constructores:
    // 1. D1() = delete
    // 2. D1(const D1&) 
    // 3. D1(D1&&)
    // 4. D1(int) <- heredado
};
 
struct B2 
{
    B2(int = 13, int = 42);
};
 
struct D2 : B2 
{
    using B2::B2;
    // El conjunto de constructores candidato heredados es
    // 1. B2(const B2&)
    // 2. B2(B2&&)
    // 3. B2(int = 13, int = 42)
    // 4. B2(int = 13)
    // 5. B2()
 
    // D2 tiene los siguientes constructores:
    // 1. D2()
    // 2. D2(const D2&)
    // 3. D2(D2&&)
    // 4. D2(int, int) <- heredado
    // 5. D2(int) <- heredado
};

La expansión de paquetes en declaraciones using hace posible formar una clase que expone los miembros sobrecargados de bases variádicas sin recursión:

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