Por qué "usar el espacio de nombres X" no está permitido dentro del nivel de clase / estructura?

class C {
  using namespace std;  // error
};
namespace N {
  using namespace std; // ok
}
int main () {
  using namespace std; // ok
}

Editar : quiero saber la motivación detrás de esto.

No lo sé exactamente, pero supongo que permitir esto en el ámbito de la clase podría causar confusión:

namespace Hello
{
    typedef int World;
}

class Blah
{
    using namespace Hello;
public:
    World DoSomething();
}

//Should this be just World or Hello::World ?
World Blah::DoSomething()
{
    //Is the using namespace valid in here?
}

Dado que no hay una forma obvia de hacer esto, el estándar simplemente dice que no se puede.

Ahora, la razón por la que esto es menos confuso cuando hablamos de ámbitos de espacio de nombres:

namespace Hello
{
    typedef int World;
}

namespace Other
{
    using namespace Hello;
    World DoSomething();
}

//We are outside of any namespace, so we have to fully qualify everything. Therefore either of these are correct:

//Hello was imported into Other, so everything that was in Hello is also in Other. Therefore this is okay:
Other::World Other::DoSomething()
{
    //We're outside of a namespace; obviously the using namespace doesn't apply here.
    //EDIT: Apparently I was wrong about that... see comments. 
}

//The original type was Hello::World, so this is okay too.
Hello::World Other::DoSomething()
{
    //Ditto
}

namespace Other
{
    //namespace Hello has been imported into Other, and we are inside Other, so therefore we never need to qualify anything from Hello.
    //Therefore this is unambiguiously right
    World DoSomething()
    {
        //We're inside the namespace, obviously the using namespace does apply here.
    }
}

Porque el estándar C ++ lo prohíbe explícitamente. De C ++ 03 §7.3.4 [namespace.udir]:

directiva-de-uso :
    usando namespace :: opt  nested-name-specifier opt  namespace-name ;

Una directiva de uso no aparecerá en el ámbito de la clase, pero puede aparecer en el ámbito del espacio de nombres o en el ámbito del bloque. [Nota: al buscar un nombre de espacio de nombres en una directiva using, solo se consideran los nombres de espacios de nombres, consulte 3.4.6. ]

¿Por qué lo prohíbe el estándar C ++? No sé, pregúntele a un miembro del comité ISO que aprobó el estándar de lenguaje.

Creo que la razón es que probablemente sería confuso. Actualmente, mientras se procesa un identificador de nivel de clase, la búsqueda buscará primero en el ámbito de la clase y luego en el espacio de nombres adjunto. Permitir el using namespacenivel a nivel de clase tendría algunos efectos secundarios sobre cómo se realiza ahora la búsqueda. En particular, tendría que realizarse en algún momento entre la verificación de ese ámbito de clase particular y la verificación del espacio de nombres adjunto. Es decir: 1) fusionar el nivel de clase y las búsquedas de nivel de espacio de nombres usado, 2) buscar el espacio de nombre usado después del alcance de clase pero antes de cualquier otro alcance de clase, 3) buscar el espacio de nombre usado justo antes del espacio de nombre adjunto. 4) la búsqueda se fusionó con el espacio de nombres adjunto.

1. Esto haría una gran diferencia, donde un identificador a nivel de clase sombrearía cualquier identificador en el espacio de nombres adjunto, pero no sombrearía un espacio de nombres usado . El efecto sería extraño, ya que el acceso al espacio de nombres usado desde una clase en un espacio de nombres diferente y desde el mismo espacio de nombres sería diferente:

.

namespace A {
   void foo() {}
   struct B {
      struct foo {};
      void f() {
         foo();      // value initialize a A::B::foo object (current behavior)
      }
   };
}
struct C {
   using namespace A;
   struct foo {};
   void f() {
      foo();         // call A::foo
   }
};

1. Busque justo después de este ámbito de clase. Esto tendría el extraño efecto de sombrear a los miembros de las clases base. La búsqueda actual no mezcla búsquedas a nivel de clase y de espacio de nombres, y al realizar la búsqueda de clases, irá hasta las clases base antes de considerar el espacio de nombres adjunto. El comportamiento sería sorprendente porque no consideraría el espacio de nombres en un nivel similar al espacio de nombres adjunto. Nuevamente, el espacio de nombres usado se priorizaría sobre el espacio de nombres adjunto.

.

namespace A {
   void foo() {}
}
void bar() {}
struct base {
   void foo();
   void bar();
};
struct test : base {
   using namespace A;
   void f() {
      foo();           // A::foo()
      bar();           // base::bar()
   }
};

1. Busque justo antes del espacio de nombres adjunto. El problema con este enfoque es, nuevamente, que sería sorprendente para muchos. Tenga en cuenta que el espacio de nombres está definido en una unidad de traducción diferente, por lo que el siguiente código no se puede ver todo a la vez:

.

namespace A {
   void foo( int ) { std::cout << "int"; }
}
void foo( double ) { std::cout << "double"; }
struct test {
   using namespace A;
   void f() {
      foo( 5.0 );          // would print "int" if A is checked *before* the
                           // enclosing namespace
   }
};

1. Fusionar con el espacio de nombres adjunto. Esto tendría exactamente el mismo efecto que aplicar la usingdeclaración en el nivel del espacio de nombres. No agregaría ningún valor nuevo a eso, pero por otro lado complicará la búsqueda de los implementadores del compilador. La búsqueda de identificadores de espacio de nombres ahora es independiente de en qué parte del código se desencadena la búsqueda. Cuando dentro de una clase, si la búsqueda no encuentra el identificador en el ámbito de la clase, recurrirá a la búsqueda de espacio de nombres, pero esa es exactamente la misma búsqueda de espacio de nombres que se usa en una definición de función, no es necesario mantener un nuevo estado. Cuando la usingdeclaración se encuentra a nivel de espacio de nombres, el contenido del espacio de nombres usado se lleva a ese espacio de nombres para todas las búsquedas que involucran el espacio de nombres. Siusing namespace se permitió a nivel de clase, habría diferentes resultados para la búsqueda de espacio de nombres del mismo espacio de nombres exacto dependiendo de dónde se desencadenó la búsqueda, y eso haría que la implementación de la búsqueda sea mucho más compleja sin valor adicional.

De todos modos, mi recomendación es no emplear la using namespacedeclaración en absoluto. Hace que el código sea más fácil de razonar sin tener que tener en cuenta el contenido de todos los espacios de nombres.

Esto probablemente no esté permitido debido a la apertura frente a la cercanía.

• Las clases y estructuras en C ++ son siempre entidades cerradas. Se definen exactamente en un lugar (aunque puede dividir la declaración y la implementación).
• los espacios de nombres se pueden abrir, volver a abrir y ampliar arbitrariamente a menudo.

La importación de espacios de nombres en clases conduciría a casos divertidos como este:

namespace Foo {}

struct Bar { using namespace Foo; };

namespace Foo {
using Baz = int; // I've just extended `Bar` with a type alias!
void baz(); // I've just extended `Bar` with what looks like a static function!
// etc.
}

Creo que es un defecto del idioma. Puede utilizar la solución alternativa a continuación. Teniendo en cuenta esta solución alternativa, es fácil sugerir reglas de resolución de conflictos de nombres para el caso en que se cambie el idioma.

namespace Hello
{
    typedef int World;
}
// surround the class (where we want to use namespace Hello)
// by auxiliary namespace (but don't use anonymous namespaces in h-files)
namespace Blah_namesp {
using namespace Hello;

class Blah
{
public:
    World DoSomething1();
    World DoSomething2();
    World DoSomething3();
};

World Blah::DoSomething1()
{
}

} // namespace Blah_namesp

// "extract" class from auxiliary namespace
using Blah_namesp::Blah;

Hello::World Blah::DoSomething2()
{
}
auto Blah::DoSomething3() -> World
{
}