Is a fully qualified class name down to global scope ever required for out-of-line member function definitions?

Question

This question got me wondering whether it is ever useful/necessary to fully qualify class names (including the global scope operator) in an out-of-class member function definition.

On the one hand, I've never seen this done before (and the syntax to properly do so seems obscure). On the other, C++ name lookup is very non-trivial, so maybe a corner case exists.

Question:

Is there ever a case where introducing an out-of-class member function definition by
ReturnType (::Fully::Qualified::Class::Name::MemberFunctionName)(...) { ... }
would differ from
ReturnType Fully::Qualified::Class::Name::MemberFunctionName(...) { ... } (no global scope :: prefix)?

^{Note that member function definitions must be put into a namespace enclosing the class, so this is not a valid example.}

Very curious what the downvoter dislikes about this question. Feedback welcome! — Max Langhof, Nov 18 '19 at 12:08
when the definition is placed in a different namespace than the declaration? Thats what I had in mind for the quesiton you link — 463035818_is_not_an_ai, Nov 18 '19 at 12:11
@formerlyknownas_463035818 That's also what I had in mind, then I tried it and realized it wouldn't work, so I wrote the question (figuring others would wonder too). — Max Langhof, Nov 18 '19 at 12:25

score 12 · Accepted Answer · answered Nov 18 '19 at 12:15

12

A using-directive can cause Fully to be ambiguous without qualification.

namespace Foo {
    struct X {
    };
}

using namespace Foo;
struct X {
    void c();
};

void X::c() { } // ambiguous
void ::X::c() { } // OK

answered Nov 18 '19 at 12:15

T.C.

133,968
17
288
421

StoryTeller - Unslander Monica · Answer 2 · 2019-11-18T12:26:15.590

5

It's necessary if one is a masochist and enjoys writing stuff like this

namespace foo {
    namespace foo {
        struct bar {
            void baz();
        };
    }

   struct bar {
       void baz();
   };

   void foo::bar::baz() {
   }

   void (::foo::bar::baz)() {
   }
}

One can of course write the second overload as foo::foo::bar::baz in global scope, but the question was whether or not the two declarations can have a different meaning. I wouldn't recommend writing such code.

edited Nov 18 '19 at 12:26

answered Nov 18 '19 at 12:17

StoryTeller - Unslander Monica

165,132
21
377
458

Yes, this is indeed a valid answer, and doesn't even need a `using`. Nice to have different cases highlighted! – Max Langhof Nov 18 '19 at 12:24

score 2 · Answer 3 · answered Nov 18 '19 at 12:16

If a using directive is used then there can be a confusing code.

Consider the following demonstrative program

#include <iostream>
#include <string>

namespace N1
{
    struct A
    {
        void f() const;
    };      
}

using namespace N1;

void A::f() const { std::cout << "N1::f()\n"; }

struct A
{
    void f() const;
};

void ::A::f() const { std::cout << "::f()\n"; }

int main() 
{
    N1::A().f();
    ::A().f();

    return 0;
}

So for readability this qualified name

void ::A::f() const { std::cout << "::f()\n"; }

shows precisely where the function is declared.

Is a fully qualified class name down to global scope ever required for out-of-line member function definitions?

3 Answers3