为什么是“使用命名空间 X；”不允许在类/结构级别？

Question

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

我想知道背后的动机。

Answer 1

我不确切知道，但我的猜测是在类范围内允许这样做可能会导致混淆：

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?
}

由于没有明显的方法可以做到这一点，标准只是说你不能。

现在，当我们谈论命名空间范围时，这不那么令人困惑的原因：

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.
    }
}

Answer 2

因为 C++ 标准明确禁止它。来自 C++03 §7.3.4 [namespace.udir]：

使用指令： 使用命名空间 ::_optnested-name-specifier_optnamespace-name ；

using-directive 不应出现在类作用域中，但可以出现在命名空间作用域或块作用域中。 [注意：在 using 指令中查找命名空间名称时，仅考虑命名空间名称，请参见 3.4.6。 ]

为什么 C++ 标准禁止它？我不知道，请咨询批准语言标准的 ISO 委员会成员。

Answer 3

我相信这样做的理由是它可能会令人困惑。目前，在处理类级别标识符时，查找将首先在类范围内搜索，然后在封闭的命名空间中搜索。在类级别允许using namespace 将对现在如何执行查找产生相当多的副作用。特别是，它必须在检查特定类范围和检查封闭命名空间之间的某个时间执行。即：1) 合并类级别和使用的命名空间级别查找，2) 在类范围之后但在任何其他类范围之前查找使用的命名空间，3) 在封闭命名空间之前查找使用的命名空间. 4) 查找与封闭命名空间合并。

1. 这将产生很大的不同，其中类级别的标识符将 shadow 封闭命名空间中的任何标识符，但它不会 shadow 一个 used 命名空间。效果会很奇怪，因为从不同命名空间中的类和从同一命名空间访问 used 命名空间会有所不同：

.

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. 在此类范围之后查找。这会产生隐藏基类成员的奇怪效果。当前查找不混合类和命名空间级别的查找，并且在执行类查找时，考虑到封闭的命名空间，它将一直到基类before。这种行为会令人惊讶，因为它不会考虑与封闭命名空间相似级别的命名空间。同样，used 命名空间将优先于封闭的命名空间。

.

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. 在封闭命名空间之前查找。这种方法的问题再次是它会让许多人感到惊讶。考虑到命名空间是在不同的翻译单元中定义的，因此无法一次看到以下代码：

.

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. 与封闭的命名空间合并。这与在命名空间级别应用 using 声明具有完全相同的效果。它不会为此添加任何新值，但另一方面会使编译器实现者的查找变得复杂。命名空间标识符查找现在独立于代码中触发查找的位置。在类内部，如果查找在类范围内找不到标识符，它将回退到命名空间查找，但这与函数定义中使用的命名空间查找完全相同，无需维护新状态。当在命名空间级别找到 using 声明时，used 命名空间的内容被带入 到该命名空间，以进行涉及该命名空间的所有 查找.如果在类级别允许using namespace，则对于完全相同的命名空间的命名空间查找将有不同的结果，具体取决于触发查找的位置，这将使查找的实现更加复杂而没有额外的价值。

无论如何，我的建议是不使用using namespace 声明。它使代码更易于推理，而无需记住所有命名空间的内容。

Answer 4

我认为这是语言的缺陷。您可以使用以下解决方法。记住这种解决方法，很容易为更改语言的情况建议名称冲突解决规则。

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
{
}

Answer 5

这可能是不允许的，因为 openness 与 closedness。

• C++ 中的类和结构始终是封闭实体。它们只在一个地方定义（尽管您可以拆分声明和实现）。
• 命名空间可以任意频繁地打开、重新打开和扩展。

将命名空间导入类会导致类似这样的有趣案例：

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.
}

Answer 6

您不能在类中使用using namespace，但您可以简单地使用#define，然后在结构中使用#undef。它的行为方式与namespace a = b;

struct foo
{
#define new_namespace old_namespace
     
    void foo2()
    {
        new_namespace::do_something();
    }

#undef new_namespace 
};