Buscar..


Introducción

Una declaración de using introduce un nombre único en el alcance actual que se declaró anteriormente en otro lugar.

Sintaxis

  • utilizando typename ( opt ) nested -name-specifier unqualified-id ;
  • utilizando :: id no calificado ;

Observaciones

Una declaración de uso es distinta de una directiva de uso , que le dice al compilador que busque en un espacio de nombres particular cuando busca cualquier nombre. Una directiva de uso comienza con el using namespace .

Una declaración de uso también es distinta de una declaración de alias, que da un nuevo nombre a un tipo existente de la misma manera que typedef . Una declaración de alias contiene un signo igual.

Importando nombres individualmente desde un espacio de nombres

Una vez que se using uso para introducir el nombre cout del espacio de nombres std en el alcance de la función main , el objeto std::cout se puede denominar solo cout .

#include <iostream>
int main() {
    using std::cout;
    cout << "Hello, world!\n";
}

Volver a declarar miembros de una clase base para evitar ocultar el nombre

Si se produce una declaración de uso en el ámbito de la clase, solo se permite volver a declarar a un miembro de una clase base. Por ejemplo, el using std::cout no está permitido en el alcance de la clase.

A menudo, el nombre redeclarado es uno que de otra manera estaría oculto. Por ejemplo, en el código de abajo, d1.foo solo hace referencia a Derived1::foo(const char*) y se producirá un error de compilación. La función Base::foo(int) está oculta y no se considera en absoluto. Sin embargo, d2.foo(42) está bien porque la declaración de uso trae Base::foo(int) al conjunto de entidades llamadas foo en Derived2 . La búsqueda de nombres luego encuentra ambos foo s y la resolución de sobrecarga selecciona Base::foo .

struct Base {
    void foo(int);
};
struct Derived1 : Base {
    void foo(const char*);
};
struct Derived2 : Base {
    using Base::foo;
    void foo(const char*);
};
int main() {
    Derived1 d1;
    d1.foo(42);  // error
    Derived2 d2;
    d2.foo(42);  // OK
}

Heredando constructores

C ++ 11

Como un caso especial, una declaración de uso en el alcance de la clase puede referirse a los constructores de una clase base directa. Esos constructores luego son heredados por la clase derivada y pueden usarse para inicializar la clase derivada.

struct Base {
    Base(int x, const char* s);
};
struct Derived1 : Base {
    Derived1(int x, const char* s) : Base(x, s) {}
};
struct Derived2 : Base {
    using Base::Base;
};
int main() {
    Derived1 d1(42, "Hello, world");
    Derived2 d2(42, "Hello, world");
}

En el código anterior, tanto Derived1 como Derived2 tienen constructores que envían los argumentos directamente al constructor correspondiente de Base . Derived1 realiza el reenvío explícitamente, mientras que Derived2 , utilizando la función C ++ 11 de heredar constructores, lo hace de manera implícita.



Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow