Вложенные неназванные пространства имен

Существует ли функциональное различие между этими двумя вложенными способами использования неназванных пространств имен:

namespace A { namespace {
  void foo() {/*...*/}
}}

namespace { namespace A {
  void foo() {/*...*/}
}}}

Насколько я вижу, оба foo получат внутренний уникальный идентификатор для единицы компиляции и могут быть доступны с помощью A::foo - но есть ли тонкая или не очень тонкая разница, которую я не вижу

Ответ 1

Точно, как вы набрали, нет разницы.

Вы можете, конечно, добавить объявления на первом уровне пространства имен, чтобы продемонстрировать примеры, и тогда это будет разница.

namespace A {
  int i;         // Accessed globally in this file as "A::i".
  namespace {
    void foo() {/*...*/}
}}


namespace {
  int i;         // Accessed globally in this file simply as "i".
  namespace A {
    void foo() {/*...*/}
}}}

Обратите внимание, что, хотя у программиста нет возможности отличить, для компилятора пространства имен различаются:

unnamed_namespaces.cpp:42:5: error: reference to ‘A’ is ambiguous
unnamed_namespaces.cpp:19:17: error: candidates are: namespace A { }
unnamed_namespaces.cpp:28:19: error:                 namespace <unnamed>::A { }

Usefull:

EDIT:

Что касается ADL (зависящий от аргументов поиск имени), я понимаю, что это не будет иметь прецедента в разрешении перегрузки для других foo(), как показано ниже:

#include    <iostream>

void foo() { std::cout << "::foo()" << std::endl; }

namespace A {
    namespace {
        void foo() { std::cout << "A::<unnamed>::foo()" << std::endl; }

        class   AClass
        {
        public:
            AClass( )
            {   foo( ); }
        };
    }
}


namespace {
    namespace B {
        void foo() { std::cout << "B::<unnamed>::foo()" << std::endl; }

        using namespace A;

        class   BClass
        {
        public:
            BClass( )
            {   foo( ); }

            ~BClass( )
            {   A::foo( );  }
        };
    }
}

int main( )
{
    A::foo( );
    B::foo( );
    foo( );

    A::AClass   a;
    B::BClass   b;

    return  0;
}

Компилятор предпочтет ближайший foo( ), если явно не указано. Поэтому конструктор BClass вызывает B::foo( ), даже имея на нем using namespace A. Чтобы вызвать A::foo( ) в деструкторе BClass, вызов должен быть явно указан.

A::<unnamed>::foo()
B::<unnamed>::foo()
::foo()
A::<unnamed>::foo()
B::<unnamed>::foo()
A::<unnamed>::foo()

Возможно, это станет яснее, если мы подумаем о вложенных пространствах имен и о том, как будет решаться зависимое от аргумента. Разница olny будет неявной using для неназванных, но она не изменит предпочтения компилятора.