En C ++, qu'est-ce qu'un «alias d'espace de noms»?

Qu'est-ce qu'un «alias d'espace de noms» en C ++? Comment est-ce utilisé?

Un alias d'espace de noms est un moyen pratique de faire référence à un nom d'espace de noms long par un nom différent et plus court.

À titre d'exemple, disons que vous vouliez utiliser les vecteurs numériques de l'uBLAS de Boost sans using namespacedirective. Indiquer l'espace de noms complet à chaque fois est fastidieux:

boost::numeric::ublas::vector<double> v;

Au lieu de cela, vous pouvez définir un alias pour boost::numeric::ublas- disons que nous voulons abréger ceci simplement en ublas:

namespace ublas = boost::numeric::ublas;


ublas::vector<double> v;

Tout simplement, la #define ne fonctionnera pas.

namespace Mine { class MyClass { public: int i; }; }
namespace His = Mine;
namespace Yours { class Mine: public His::MyClass { void f() { i = 1; } }; }

Compile bien. Vous permet de contourner les collisions d'espace de nom / nom de classe.

namespace Nope { class Oops { public: int j; }; }
#define Hmm Nope
namespace Drat { class Nope: public Hmm::Oops { void f () { j = 1; } }; }

Sur la dernière ligne, "Hmm: Oups" est une erreur de compilation. Le pré-processeur le change en Nope :: Oops, mais Nope est déjà un nom de classe.

En savoir plus sur ce sujet http://channel9.msdn.com/Series/C9-Lectures-Stephan-T-Lavavej-Core-C-/Stephan-T-Lavavej-Core-C-1-of-n

Il s'agit de choisir un alias pour un nom d'espace de noms long, tel que:

namespace SHORT = NamespaceFirst::NameSpaceNested::Meow

Puis plus tard, vous pouvez taperef

typedef SHORT::mytype

au lieu de

typedef NamespaceFirst::NameSpaceNested::Meow::mytype

Cette syntaxe ne fonctionne que pour les espaces de noms, ne peut pas inclure de classes, de types après le namespace NAME =

Notez également que les alias d'espace de noms et les directives d'utilisation sont résolus au moment de la compilation et non au moment de l'exécution. (Plus précisément, ce sont tous les deux des outils utilisés pour indiquer au compilateur où chercher ailleurs lors de la résolution de noms, s'il ne trouve pas un symbole particulier dans la portée actuelle ou l'une de ses portées parentes.) Par exemple, aucune de ces compiler:

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;

Maintenant, un esprit curieux peut avoir remarqué que des constexprvariables sont également utilisées au moment de la compilation, et se demander si elles peuvent être utilisées en conjonction avec un alias ou une directive. À ma connaissance, ils ne le peuvent pas, bien que je puisse me tromper à ce sujet. Si vous avez besoin de travailler avec des variables portant le même nom dans différents espaces de noms et de choisir entre elles de manière dynamique, vous devrez utiliser des références ou des pointeurs.

// 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é de ce qui précède peut être limitée, mais elle devrait servir l'objectif.

(Mes excuses pour les fautes de frappe que j'ai pu manquer dans ce qui précède.)

L'espace de noms est utilisé pour éviter les conflits de noms.

Par exemple:

namespace foo {
    class bar {
        //define it
    };
}

namespace baz {
    class bar {
        // define it
    };
}

Vous avez maintenant deux barres de nom de classes, qui sont complètement différentes et séparées grâce à l'espacement des noms.

Le "using namespace" que vous montrez est de sorte que vous n'ayez pas à spécifier l'espace de noms pour utiliser des classes dans cet espace de noms. ie std :: string devient une chaîne.

ma ressource: https://www.quora.com/What-is-namespace-in-C++-1