Risposte:
Un alias dello spazio dei nomi è un modo conveniente per fare riferimento a un nome di spazio dei nomi lungo con un nome diverso e più corto.
Ad esempio, supponiamo che tu voglia utilizzare i vettori numerici di uBLAS di Boost senza una using namespacedirettiva. Dichiarare l'intero spazio dei nomi ogni volta è ingombrante:
boost::numeric::ublas::vector<double> v;Invece, puoi definire un alias per boost::numeric::ublas- diciamo che vogliamo abbreviare questo per solo ublas:
namespace ublas = boost::numeric::ublas;
ublas::vector<double> v;Molto semplicemente, #define non funzionerà.
namespace Mine { class MyClass { public: int i; }; }
namespace His = Mine;
namespace Yours { class Mine: public His::MyClass { void f() { i = 1; } }; }Compila bene. Ti consente di aggirare le collisioni di nomi di spazi / classi.
namespace Nope { class Oops { public: int j; }; }
#define Hmm Nope
namespace Drat { class Nope: public Hmm::Oops { void f () { j = 1; } }; }Nell'ultima riga, "Hmm: Oops" è un errore di compilazione. Il pre-processore lo cambia in Nope :: Oops, ma Nope è già un nome di classe.
Maggiori informazioni su questo argomento http://channel9.msdn.com/Series/C9-Lectures-Stephan-T-Lavavej-Core-C-/Stephan-T-Lavavej-Core-C-1-of-n
Si tratta solo di scegliere un alias per un nome di spazio dei nomi looong, come:
namespace SHORT = NamespaceFirst::NameSpaceNested::Meow
Successivamente, è possibile digitare
typedef SHORT::mytype
invece di
typedef NamespaceFirst::NameSpaceNested::Meow::mytype
Questa sintassi funziona solo per gli spazi dei nomi, non può includere classi, tipi dopo namespace NAME =
Si noti inoltre che gli alias dello spazio dei nomi e l'utilizzo delle direttive vengono risolti in fase di compilazione, non in fase di esecuzione. (Più specificamente, sono entrambi strumenti usati per dire al compilatore dove altro cercare quando si risolvono i nomi, se non riesce a trovare un simbolo particolare nell'ambito corrente o in uno dei suoi ambiti padre. Ad esempio, nessuno di questi compilare:
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;Ora, una mente curiosa potrebbe aver notato che le constexprvariabili vengono utilizzate anche in fase di compilazione e si chiede se possano essere utilizzate insieme a un alias o una direttiva. Per quanto ne sappia, non possono, anche se potrei sbagliarmi al riguardo. Se devi lavorare con variabili con nome identico in spazi di nomi diversi e sceglierle tra loro dinamicamente, dovresti usare riferimenti o puntatori.
// 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;
}
}L'utilità di quanto sopra può essere limitata, ma dovrebbe servire allo scopo.
(Mi scuso per eventuali errori di battitura che potrei aver perso in quanto sopra.)
Lo spazio dei nomi viene utilizzato per prevenire conflitti di nomi.
Per esempio:
namespace foo {
class bar {
//define it
};
}
namespace baz {
class bar {
// define it
};
}Ora hai due classi di nomi, completamente diverse e separate grazie allo spazio dei nomi.
Lo "usa lo spazio dei nomi" che mostri è in modo che non devi specificare lo spazio dei nomi per usare le classi all'interno di quello spazio dei nomi. cioè std :: string diventa stringa.
la mia risorsa: https://www.quora.com/What-is-namespace-in-C++-1