Respuestas:
Un alias de espacio de nombres es una forma conveniente de referirse a un nombre de espacio de nombres largo con un nombre diferente y más corto.
Como ejemplo, supongamos que desea utilizar los vectores numéricos de uBLAS de Boost sin una using namespacedirectiva. Establecer el espacio de nombres completo cada vez es engorroso:
boost::numeric::ublas::vector<double> v;En su lugar, puede definir un alias para boost::numeric::ublas- digamos que queremos abreviar esto para simplemente ublas:
namespace ublas = boost::numeric::ublas;
ublas::vector<double> v;Simplemente, el #define no funcionará.
namespace Mine { class MyClass { public: int i; }; }
namespace His = Mine;
namespace Yours { class Mine: public His::MyClass { void f() { i = 1; } }; }Compila bien. Le permite evitar colisiones de nombres de clase / espacio de nombres.
namespace Nope { class Oops { public: int j; }; }
#define Hmm Nope
namespace Drat { class Nope: public Hmm::Oops { void f () { j = 1; } }; }En la última línea, "Hmm: Vaya" es un error de compilación. El preprocesador lo cambia a Nope :: Oops, pero Nope ya es un nombre de clase.
Más sobre este tema http://channel9.msdn.com/Series/C9-Lectures-Stephan-T-Lavavej-Core-C-/Stephan-T-Lavavej-Core-C-1-of-n
Se trata de elegir un alias para un nombre de espacio de nombres muy largo, como:
namespace SHORT = NamespaceFirst::NameSpaceNested::Meow
Luego, más tarde, puede escribir def
typedef SHORT::mytype
en vez de
typedef NamespaceFirst::NameSpaceNested::Meow::mytype
Esta sintaxis solo funciona para espacios de nombres, no puede incluir clases, tipos después de namespace NAME =
También tenga en cuenta que los alias de espacio de nombres y el uso de directivas se resuelven en tiempo de compilación, no en tiempo de ejecución. (Más específicamente, ambas herramientas se usan para indicarle al compilador dónde más buscar al resolver nombres, si no puede encontrar un símbolo en particular en el alcance actual o en cualquiera de sus ámbitos principales). Por ejemplo, ninguno de estos compilar:
namespace A {
int foo;
namespace AA {
int bar;
} // namespace AA
namespace AB {
int bar;
} // namespace AB
} // namespace A
namespace B {
int foo;
namespace BA {
int bar;
} // namespace BA
namespace BB {
int bar;
} // namespace BB
} // namespace B
bool nsChooser1, nsChooser2;
// ...
// This doesn't work.
namespace C = (nsChooser1 ? A : B);
C::foo = 3;
// Neither does this.
// (Nor would it be advisable even if it does work, as compound if-else blocks without braces are easy to inadvertently break.)
if (nsChooser1)
if (nsChooser2)
using namespace A::AA;
else
using namespace A::AB;
else
if (nsChooser2)
using namespace B::BA;
else
using namespace B::BB;Ahora, una mente curiosa puede haber notado que las constexprvariables también se usan en el momento de la compilación, y se pregunta si pueden usarse junto con un alias o una directiva. Que yo sepa, no pueden, aunque puedo estar equivocado sobre esto. Si necesita trabajar con variables con nombres idénticos en diferentes espacios de nombres y elegir dinámicamente entre ellas, deberá usar referencias o punteros.
// Using the above namespaces...
int& foo = (nsChooser1 ? A::foo : B::foo);
int* bar;
if (nsChooser1) {
if (nsChooser2) {
bar = &A::AA::bar;
} else {
bar = &A::AB::bar;
}
} else {
if (nsChooser2) {
bar = &B::BA::bar;
} else {
bar = &B::BB::bar;
}
}La utilidad de lo anterior puede ser limitada, pero debe cumplir el propósito.
(Mis disculpas por cualquier error tipográfico que me haya perdido en lo anterior).
El espacio de nombres se usa para evitar conflictos de nombres.
Por ejemplo:
namespace foo {
class bar {
//define it
};
}
namespace baz {
class bar {
// define it
};
}Ahora tiene una barra de nombre de dos clases, que son completamente diferentes y separadas gracias al espacio de nombres.
El "uso del espacio de nombres" que muestra es para que no tenga que especificar el espacio de nombres para usar clases dentro de ese espacio de nombres. es decir, std :: string se convierte en string.
mi recurso: https://www.quora.com/What-is-namespace-in-C++-1