c++ - É sempre necessário um nome de classe totalmente qualificado para o escopo global para definições de função de membro fora de linha?




name-lookup global-scope (2)

É necessário se alguém é masoquista e gosta de escrever coisas assim

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

   struct bar {
       void baz();
   };

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

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

É claro que se pode escrever a segunda sobrecarga como foo::foo::bar::baz no escopo global, mas a questão era se as duas declarações podem ou não ter um significado diferente. Eu não recomendaria escrever esse código.

This pergunta me fez pensar se é útil / necessário qualificar totalmente os nomes de classe (incluindo o operador de escopo global) em uma definição de função de membro fora da classe.

Por um lado, nunca vi isso antes (e a sintaxe para fazê-lo corretamente parece obscura). Por outro lado, a pesquisa de nomes em C ++ não é trivial, portanto, talvez exista uma caixa de canto.

Pergunta, questão:

Existe um caso em que a introdução de uma definição de função membro fora da classe por
ReturnType (::Fully::Qualified::Class::Name::MemberFunctionName)(...) { ... }
diferiria de
ReturnType Fully::Qualified::Class::Name::MemberFunctionName(...) { ... } (sem escopo global :: prefixo)?

Observe que as definições de função de membro devem ser colocadas em um espaço para nome que inclua a classe, portanto, this não é um exemplo válido.


Se uma diretiva using for usada, pode haver um código confuso.

Considere o seguinte programa demonstrativo

#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;
}

Portanto, para facilitar a leitura, esse nome qualificado

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

mostra exatamente onde a função é declarada.





scope-resolution-operator