Why is “using namespace X;” not allowed at class/struct level?

by

I don’t know exactly, but my guess is that allowing this at class scope could cause confusion:

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

Since there is no obvious way of doing this, the standard just says you can’t.

Now, the reason this is less confusing when we’re talking namespace scopes:

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

More Related Contents:

  1. scope of using declaration within a namespace
  2. What is the use of “using namespace std”? [duplicate]
  3. reinterpret_cast creating a trivially default-constructible object
  4. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  5. When is a private constructor not a private constructor?
  6. When using C headers in C++, should we use functions from std:: or the global namespace?
  7. Is it still safe to delete nullptr in c++0x?
  8. Template partial ordering – why does partial deduction succeed here
  9. Matching alias template as template argument
  10. Unsequenced value computations (a.k.a sequence points)
  11. Do I really need to implement user-provided constructor for const objects?
  12. Do all pointers have the same size in C++?
  13. Why are some functions in not in the std namespace?
  14. Force all classes to implement / override a ‘pure virtual’ method in multi-level inheritance hierarchy
  15. Can class template constructors have a redundant template parameter list in c++20
  16. Is std::abs(0u) ill-formed?
  17. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  18. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  19. Implementing a std::vector like container without undefined behavior
  20. C++ – Why static member function can’t be created with ‘const’ qualifier
  21. Is a constexpr array necessarily odr-used when subscripted?
  22. Does C have One Definition Rule like C++?
  23. Dangling references and undefined behavior
  24. Why do (only) some compilers use the same address for identical string literals?
  25. Can we apply content not explicitly cited from the normative references to the C++ standard?
  26. Calling delete on NULL pointers – C++03 vs C++11
  27. C++ operator % guarantees
  28. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  29. Scope resolution operator being used twice
  30. Is char default-promoted?

Leave a Comment