嵌套未命名的命名空间

Question

这两个未命名的命名空间的嵌套用法之间是否存在功能差异:

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

和

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

据我所知,两个foos都将获得每个编译单元的内部唯一标识符,并且可以使用A::foo- 但是有一个微妙的或不那么微妙的区别,我没有看到？

Answer 1

正如您输入的那样,没有区别.

当然,您可以在第一级命名空间中向booth示例添加声明,然后这将是一个区别.

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 { }

有用:

• 嵌套的匿名命名空间？
• 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

编辑:

关于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在未命名的那些上,但它不会改变编译器的首选项.