Ограниченная директива использования в объявлении структуры/класса?

Учитывая, что объявления 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));

Это аналогично объявлению блока для локальных переменных в функции. Но в этом случае вы объявляете очень ограниченную область, в которой вы будете изменять правила поиска имени.

Иногда я делаю это, чтобы добиться почти такого же эффекта:

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;

Может быть, псевдоним пространства имен?

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

Вы можете использовать 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);
};

Очевидным преимуществом пространств имен является то, что они позволяют избежать конфликтов имен. Однако при введении всего пространства имен в объявление класса это преимущество аннулируется. Вполне возможно, что функция в пространстве имен System может конфликтовать с вашей собственной функцией Bar::MemberFunc. Вы даже отмечаете это в своем примере кода, когда добавляете комментарий «нет конфликта с этим».

Вы, очевидно, не хотите вводить в свой класс целые пространства имен следующим образом:

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

И вы не можете добавить более узкие операторы использования, подобные этому, в объявление класса. Помещение их непосредственно в объявление класса является незаконным.

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. Ваши объявления функций чисты.

Пожалуйста, поправьте меня, если я ошибаюсь; Я только кратко протестировал это. Быстро написал пример, и он скомпилировался.