Respostas:
Um alias de namespace é uma maneira conveniente de se referir a um nome de namespace longo por um nome menor e diferente.
Como exemplo, digamos que você queira usar os vetores numéricos do uBLAS do Boost sem uma using namespacediretiva. Declarar o espaço para nome completo toda vez é complicado:
boost::numeric::ublas::vector<double> v;Em vez disso, você pode definir um alias para boost::numeric::ublas- digamos que queremos abreviar isso para apenas ublas:
namespace ublas = boost::numeric::ublas;
ublas::vector<double> v;Simplesmente, o #define não funcionará.
namespace Mine { class MyClass { public: int i; }; }
namespace His = Mine;
namespace Yours { class Mine: public His::MyClass { void f() { i = 1; } }; }Compila bem. Permite contornar colisões de namespace / nome de classe.
namespace Nope { class Oops { public: int j; }; }
#define Hmm Nope
namespace Drat { class Nope: public Hmm::Oops { void f () { j = 1; } }; }Na última linha, "Hmm: Opa" é um erro de compilação. O pré-processador o altera para Nope :: Oops, mas Nope já é um nome de classe.
Mais sobre este tópico http://channel9.msdn.com/Series/C9-Lectures-Stephan-T-Lavavej-Core-C-/Stephan-T-Lavavej-Core-C-1-of-n
Trata-se de escolher um alias para um nome de espaço de nome longo, como:
namespace SHORT = NamespaceFirst::NameSpaceNested::Meow
Depois, você pode digitar
typedef SHORT::mytype
ao invés de
typedef NamespaceFirst::NameSpaceNested::Meow::mytype
Essa sintaxe funciona apenas para namespaces, não pode incluir classes, tipos após o namespace NAME =
Observe também que os aliases de namespace e o uso de diretivas são resolvidos no tempo de compilação, não no tempo de execução. (Mais especificamente, as duas ferramentas são usadas para informar ao compilador onde mais procurar ao resolver nomes, se ele não conseguir encontrar um símbolo específico no escopo atual ou em qualquer um de seus escopos pai.) Por exemplo, nenhum deles será 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;Agora, uma mente curiosa pode ter notado que as constexprvariáveis também são usadas em tempo de compilação e se pergunta se elas podem ser usadas em conjunto com um alias ou uma diretiva. Que eu saiba, eles não podem, embora eu possa estar errado sobre isso. Se você precisar trabalhar com variáveis nomeadas de forma idêntica em diferentes espaços para nome e escolher entre elas dinamicamente, seria necessário usar referências ou ponteiros.
// 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;
}
}A utilidade do acima exposto pode ser limitada, mas deve servir ao propósito.
(Minhas desculpas por quaisquer erros de digitação que eu possa ter perdido no item acima.)
O espaço para nome é usado para evitar conflitos de nome.
Por exemplo:
namespace foo {
class bar {
//define it
};
}
namespace baz {
class bar {
// define it
};
}Agora você tem duas barras de nomes de classes, que são completamente diferentes e separadas graças ao espaço para nome.
O "using namespace" que você mostra é para que você não precise especificar o namespace para usar as classes nesse namespace. ou seja, std :: string se torna string.
meu recurso: https://www.quora.com/What-is-namespace-in-C++-1