结构/类声明中的作用域 using 指令？

Question

我发现我的 C++ 头文件对于所有完全限定的类型（深达 4 个嵌套命名空间）都非常难以阅读（并且键入起来非常乏味）。这就是问题（所有答案都给出了实现它的混乱替代方案，但这不是问题）：是否有强有力的理由反对在结构和类中引入作用域 using-directive在 C++ 语言中（虽然允许在函数中使用作用域声明）？

例如，

class Foo : public Bar
{
    using namespace System;
    using namespace System::Network;
    using namespace System::Network::Win32::Sockets;
    using Bar::MemberFunc; // no conflict with this

    // e.g. of how messy my header files are without scoped using-directive
    void FooBar(System::Network::Win32::Sockets::Handle handle, System::Network::Win32::Sockets::Error& error /*, more fully-qualified param declarations... */);
};

由于 namespace 是一个关键字，我认为它足够独特，不会与作用域 using 声明（例如 Bar::MemberFunc）发生冲突。

编辑：仔细阅读问题--->我已经加粗了。提醒：我们不讨论如何提高此处示例的可读性。建议如何在 C++ 语言中实现范围内的 using-directive（即通过添加关键字/构造等）并不是一个答案（如果您可以找到一种优雅的方法来使用现有的 C++ 来实现此目的）语言标准，那么这当然是一个答案）！

Answer 1

有时我这样做是为了达到几乎相同的效果：

namespace detail {
    using namespace System;
    using namespace System::Network;
    using namespace System::Network::Win32::Sockets;

    class Foo : public Bar
    {
         void FooBar(Handle handle, Error& error);
    };
}
using detail::Foo;

Answer 2

鉴于类作用域中的 using 声明不是继承的，因此这是可行的。该名称仅在该类声明内或嵌套类的声明内有效。但我认为这有点超载了类的概念，而它的想法应该更大。

在 Java 和 Python 中，单个文件以特殊方式处理。您可以使用 import 声明将其他名称空间中的名称注入到文件中。这些名称（嗯，不完全是 Python，但这里解释起来太复杂）仅在该文件中可见。

对我来说，这种能力不依赖于类声明，而是赋予它自己的范围。如果有意义的话，这将允许注入的名称在多个类声明中使用，甚至在函数定义中使用。

这是我更喜欢的一个想法，因为它允许这些事情，同时仍然为您提供使用声明的类级别的好处：

using {
   // A 'using' block is a sort of way to fence names in.  The only names
   // that escape the confines of a using block are names that are not
   // aliases for other things, not even for things that don't have names
   // of their own.  These are things like the declarations for new
   // classes, enums, structs, global functions or global variables.
   // New, non-alias names will be treated as if they were declared in
   // the scope in which the 'using' block appeared.

   using namespace ::std;
   using ::mynamespace::mytype_t;
   namespace mn = ::mynamespace;
   using ::mynamespace::myfunc;

   class AClass {
     public:
      AClass(const string &st, mytype_t me) : st_(st), me_(me) {
         myfunc(&me_);
      }

     private:
      const string st_;
      mn::mytype_t me_;
   };
// The effects of all typedefs, using declarations, and namespace
// aliases that were introduced at the level of this block go away
// here.  typedefs and using declarations inside of nested classes
// or namespace declarations do not go away.
} // end using.

// Legal because AClass is treated as having been declared in this
// scope.
AClass a("Fred", ::mynamespace::mytype_t(5));

// Not legal, alias mn no longer exists.
AClass b("Fred", mn::mytype_t);

// Not legal, the unqualified name myfunc no longer exists.
AClass c("Fred", myfunc(::mynamespace::mytype_t(5));

这类似于在函数中声明局部变量的块。但在这种情况下，您声明的范围非常有限，您将在其中更改名称查找规则。

Answer 3

您可以在类声明中使用 typedef 来实现相同的效果

class Foo : public Bar
{
      typedef System::Network::Win32::Sockets::Handle Handle;
      typedef System::Network::Win32::Sockets::Error Error;

      void FooBar(Handle handle, Error& error);
};

Answer 4

也许命名空间别名？

namespace MyScope = System::Network::Win32::Sockets;

Answer 5

命名空间的明显好处是它们可以让您避免命名冲突。然而，通过将整个命名空间引入到类声明中，这种好处就消失了。 System 命名空间中的函数完全有可能与您自己的 Bar::MemberFunc 函数发生冲突。当您添加注释“与此不冲突”时，您甚至会在示例代码中注意到这一点。

您显然不想像这样将整个名称空间引入到您的类中：

using namespace System;
using namespace System::Network;
using namespace System::Network::Win32::Sockets;

并且您不能将像这样的范围更窄的 using 语句添加到类声明中。将它们直接放入类声明中是非法的。

using System::Network::Win32::Sockets::Handle;
using System::Network::Win32::Sockets::Error;

---

您可以做的是使用未命名的命名空间。因此，您的头文件将如下所示：

namespace {
    using System::Network::Win32::Sockets::Handle;
    using System::Network::Win32::Sockets::Error;
}

class Foo : public Bar
{
    using Bar::MemberFunc;

    // clean!
    void FooBar(Handle handle, Error& error /*, more declarations*/);
};

---

这具有三个明显的优点。

1. 整个命名空间的内容就不介绍了。这有助于更轻松地避免命名冲突。
2. 在类声明之前，您有一个列表，其中列出了您的类正常工作所依赖的内容。
3. 你的函数声明很干净。

如果我错了，请纠正我；我只是简单地测试了这一点。很快就写了一个例子，并编译了。