ทำไม“ ใช้เนมสเปซ X;” ไม่อนุญาตให้อยู่ในระดับชั้น / โครงสร้าง?

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

แก้ไข : ต้องการทราบแรงจูงใจเบื้องหลัง

ฉันไม่รู้แน่ชัด แต่ฉันเดาว่าการปล่อยให้สิ่งนี้ในขอบเขตชั้นเรียนอาจทำให้เกิดความสับสน:

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

เนื่องจากมาตรฐาน C ++ ห้ามไว้อย่างชัดเจน จาก C ++ 03 §7.3.4 [namespace.udir]:

การใช้คำสั่ง :
    โดยใช้ namespace :: การเลือก ที่ซ้อนกันชื่อ-ระบุการเลือก namespace ชื่อ ;

ใช้-สั่งจะไม่ปรากฏในขอบเขตของคลาส แต่อาจปรากฏอยู่ในขอบเขต namespace หรืออยู่ในขอบเขตบล็อก [หมายเหตุ: เมื่อค้นหาชื่อเนมสเปซในคำสั่งการใช้จะพิจารณาเฉพาะชื่อเนมสเปซเท่านั้นดู 3.4.6 ]

เหตุใดมาตรฐาน C ++ จึงห้ามไว้ ฉันไม่ทราบให้ถามสมาชิกของคณะกรรมการ ISO ที่อนุมัติมาตรฐานภาษา

ฉันเชื่อว่าเหตุผลคือมันอาจจะสับสน ขณะนี้ในขณะประมวลผลตัวระบุระดับคลาสการค้นหาจะค้นหาในขอบเขตคลาสก่อนจากนั้นในเนมสเปซที่แนบมา การอนุญาตusing namespaceในระดับชั้นเรียนจะมีผลข้างเคียงค่อนข้างมากกับการดำเนินการค้นหาในขณะนี้ โดยเฉพาะอย่างยิ่งจะต้องดำเนินการบางครั้งระหว่างการตรวจสอบขอบเขตคลาสนั้น ๆ และการตรวจสอบเนมสเปซที่แนบมา นั่นคือ: 1) รวมระดับคลาสและใช้การค้นหาระดับเนมสเปซ 2) ค้นหาเนมสเปซที่ใช้หลังขอบเขตคลาส แต่ก่อนขอบเขตคลาสอื่น ๆ 3) ค้นหาเนมสเปซที่ใช้ก่อนปิดเนมสเปซ 4) การค้นหาที่ผสานกับเนมสเปซที่แนบมา

1. นี้จะทำให้ความแตกต่างใหญ่ที่ตัวระบุในระดับชั้นจะเงาระบุใด ๆ ใน namespace ล้อมรอบ แต่มันจะไม่เงาใช้ namespace เอฟเฟกต์จะแปลกในการเข้าถึงเนมสเปซที่ใช้แล้วจากคลาสในเนมสเปซที่แตกต่างกันและจากเนมสเปซเดียวกันจะแตกต่างกัน:

.

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. ค้นหาทันทีหลังจากขอบเขตของคลาสนี้ สิ่งนี้จะมีเอฟเฟกต์แปลก ๆ ของสมาชิกคลาสพื้นฐานที่เป็นเงา การค้นหาในปัจจุบันไม่ได้ผสมการค้นหาระดับคลาสและเนมสเปซและเมื่อทำการค้นหาคลาสมันจะไปจนถึงคลาสพื้นฐานก่อนที่จะพิจารณาเนมสเปซที่แนบมา พฤติกรรมจะน่าแปลกใจที่จะไม่พิจารณาเนมสเปซในระดับที่ใกล้เคียงกับเนมสเปซที่ปิดล้อม อีกครั้งเนมสเปซที่ใช้จะถูกจัดลำดับความสำคัญเหนือเนมสเปซที่ปิดล้อม

.

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พบการประกาศที่ระดับเนมสเปซเนื้อหาของเนมสเปซที่ใช้จะถูกนำเข้าสู่เนมสเปซนั้นสำหรับการค้นหาทั้งหมดที่เกี่ยวข้องกับเนมสเปซ ถ้าusing namespace ได้รับอนุญาตในระดับชั้นเรียนจะมีผลลัพธ์ที่แตกต่างกันสำหรับการค้นหาเนมสเปซของเนมสเปซเดียวกันโดยขึ้นอยู่กับว่าการค้นหาถูกเรียกใช้จากที่ใดและจะทำให้การใช้งานการค้นหามีความซับซ้อนมากขึ้นโดยไม่มีค่าเพิ่มเติม

อย่างไรก็ตามคำแนะนำของฉันคือไม่ใช้การusing namespaceประกาศเลย ทำให้โค้ดใช้เหตุผลได้ง่ายขึ้นโดยไม่ต้องคำนึงถึงเนื้อหาของเนมสเปซทั้งหมด

สิ่งนี้อาจไม่ได้รับอนุญาตเนื่องจากการเปิดกว้างและการปิด

• คลาสและโครงสร้างใน 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.
}

ฉันคิดว่ามันเป็นความบกพร่องของภาษา คุณอาจใช้วิธีแก้ปัญหาด้านล่าง โปรดทราบว่าวิธีแก้ปัญหานี้เป็นเรื่องง่ายที่จะแนะนำกฎของการแก้ปัญหาความขัดแย้งของชื่อสำหรับกรณีที่จะเปลี่ยนภาษา

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