C++
Utilizando declaración
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
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.