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

Ответ 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:

• Вложенное анонимное пространство имен?
• http://www.codingunit.com/cplusplus-tutorial-namespaces-and-anonymous-namespaces
• http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Funnamed_namespaces.htm
• http://www.informit.com/articles/article.aspx?p=31783&seqNum=6
• http://msdn.microsoft.com/en-us/library/yct4x9k5%28v=vs.80%29.aspx

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 для неназванных, но она не изменит предпочтения компилятора.