¿Es posible envolver o fusionar espacios de nombres separados?

Question

Parece que recuerdo haber visto notas en alguna parte de una manera de combinar múltiples espacios de nombres en uno solo.

Ahora, en busca de dichas notas, no las encuentro, incluso buscando utilizando términos de búsqueda peinando, agrupando, fusionando y envolviendo No se me ocurre nada. Tal vez no entendí lo que vi antes. No tengo una aplicación específica para esto, es solo una curiosidad y es un poco artificial.

Pero, a partir de dos espacios de nombres ...

namespace a {int func() {return 1;}} 
namespace b {int func() {return 2;}} 

que estaba buscando a la sintaxis ya sea simplemente envolverlos en otro nombre - después del hecho - (sí, sé que puedo reescribirlo de forma anidada) o combinarlos en un nuevo espacio. Pero encontré que si agrego uno de los espacios de nombres que funciona mucho.

namespace c {namespace a{ int func2() {return 3;}} } 


int main(int argc, char **argv) 
{ 
    int a = a::func();   // normal case 
    int c = c::a::func2();  // wrapped and added to 

    //int c = c::func2();  // doesn't work 
    //int d = a::func2();  // doesn't work 
} 

La pregunta son:

1) ¿hay sintaxis que simplemente combina los dos espacios en uno nuevo?

2) ¿hay una sintaxis para envolver los espacios sin agregar más a los subespacios?

Answer 1

Usted puede hacer esto:

namespace c 
{ 
    using namespace a; 
    using namespace b; 
} 

Pero si A y B tienen elementos con los mismos nombres, usted no será capaz de utilizarlas del espacio de nombres c.

Answer 2

Puede envolver los espacios de nombres en un nuevo uno como este:

namespace c { 
    namespace a { using namespace ::a; } 
    namespace b { using namespace ::b; } 
} 

Answer 3

La mejor solución ya que C++ 11 es:

namespace c 
{ 
    inline namespace a { using namespace ::a; } 
    inline namespace b { using namespace ::b; } 
} 

De esta manera los nombres que no entren en conflicto puede calificar solo por c y puede resolver conflictos calificando c::a o c::b.

ej .:

namespace a 
{ 
    auto foo_a() { cout << "a::foo_a" << endl; } 
    auto foo() { cout << "a::foo" << endl; } 
} 
namespace b 
{ 
    auto foo_b() { cout << "b::foo_b" << endl; } 
    auto foo() { cout << "b::foo" << endl; } 
} 

namespace c 
{ 
    inline namespace a { using namespace ::a; } 
    inline namespace b { using namespace ::b; } 
} 

int main() 
{ 
    c::foo_a(); 
    c::foo_b(); 

    c::a::foo(); 
    c::b::foo(); 

    return 0; 
}