在其命名空间外定义的类成员函数

Question

The following code compiles perfectly with the latest MSVC, GCC and CLang available at godbolt online compiler explorer site. I wonder why:

namespace ns
{
    struct Test
    {
        void foo();
    };
}

using namespace ns;

// Alert! Member function defined outside its namespace!
void Test::foo()
{
}

int main()
{
    ns::Test   obj;
    obj.foo();
    return 0;
}

cppreference claims that if a member function is defined outside its class, then it must be defined at the namespace of that class. See the very top of the cppreference page about member functions .

But still, the compilers accept the code. It's really unlikely that all three independent compilers have the same bug, right? So, is there a good reason behind them accepting such code?

Answer 1

Quoting C++17 (n4659) 12.2.1 [class.mfct]/1:

A member function definition that appears outside of the class definition shall appear in a namespace scope enclosing the class definition.

This means it must be defined in the namespace which contains the class, or any parent namespace of that namespace. In your case, it's defined in the global namespace, which does indeed enclose (indirectly) the class definition.

Answer 2

12.2.1 Member functions [class.mfct]

A member function may be defined (11.4) in its class definition, in which case it is an inline member function (10.1.6), or it may be defined outside of its class definition if it has already been declared but not defined in its class definition. A member function definition that appears outside of the class definition shall appear in a namespace scope enclosing the class definition.

This does not mean the definition must appear in the immediately surrounding scope . It can appear in any enclosing namespace, even if that is several layers up.

However, this would be illegal:

namespace a {
    struct X {
        void Y();
    };
}
namespace b { // not an enclosing namespace
    void X::Y()
    {
        std::cout << "Do a thing!\n";
    }
}

Answer 3

using namespace ns;

5) using-directive: From the point of view of unqualified name lookup of any name after a using-directive and until the end of the scope in which it appears, every name from ns_name is visible as if it were declared in the nearest enclosing namespace which contains both the using-directive and ns_name.

It means that in the current scope ns can be omitted from addressing something inside that namespace.

As such when you write this code:

using namespace std;
vector<string> vectorofstrings;

You don't have to write

std::vector<std::string> vectorofstrings;

The namespace of a class is the name of the class. So if you have:

namespace aNamespace{

class aClass{
    int aMember;
    void aFunction();
};

}

Then the fully qualified lookup is ::aNamespace::aClass and a function must be defined as being part of void ::aNamespace::aClass::aFunction(){}