嵌套未命名的名称空间

| 这两种未命名名称空间的嵌套用法之间在功能上有区别:
namespace A { namespace {
  void foo() {/*...*/}
}}
namespace { namespace A {
  void foo() {/*...*/}
}}}
据我所知,两个ѭ2都将在每个编译单元中获得一个内部唯一标识符,并且可以通过
A::foo
进行访问-但是我没有看到细微的或不太细微的差异吗?     
已邀请:
        就像您键入的一样,没有任何区别。 当然,您可以在名称空间的第一级中将声明添加到展位示例,然后有所不同。
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/zh-CN/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;
}
除非明确指定,否则编译器将首选最接近的“ 8”。 因此,
BClass
构造函数即使在having11上也调用
B::foo( )
。 要在
BClass
析构函数上调用
A::foo( )
,该调用必须经过明确限定。
A::<unnamed>::foo()
B::<unnamed>::foo()
::foo()
A::<unnamed>::foo()
B::<unnamed>::foo()
A::<unnamed>::foo()
如果我们考虑嵌套命名空间以及如何解决依赖于参数的问题,也许会变得更加清楚。唯一的区别是未命名的区别为ѭ15,但不会改变编译器的首选项。     

要回复问题请先登录注册