espacios de nombres sin nombre de la jerarquización

Question

¿Existe una diferencia funcional entre estos dos usos anidados de espacios de nombres sin nombre:

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

y

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

Por lo que veo, ambos foo s obtendrán un interno único identificador por unidad de compilación y se puede acceder con A::foo - pero ¿hay una diferencia sutil o no tan sutil que no estoy viendo?

Answer 1

Exactamente como ha escrito, no hay diferencia.

Puede, por supuesto, agregar declaraciones en el primer nivel del espacio de nombres a los ejemplos del stand y luego será una diferencia.

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() {/*...*/} 
}}} 

Tenga en cuenta que, a pesar de que el programador no tiene manera de distinguir, por el compilador, los espacios de nombres son distintos:

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

Útil:

• Nested anonymous namespace?
• 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:

Con respecto a ADL (Argumento dependiente de búsqueda de nombre), entiendo que va a haber ninguna diferencia prioridad en la resolución de sobrecarga para otra foo() de la siguiente manera:

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

C ompiler preferirá el foo() más cercano a menos que se especifique explícitamente. Así que BClass constructor llama a B::foo() incluso teniendo un using namespace A en él. Para llamar al A::foo() en BClass destructor, la llamada debe estar explícitamente habilitada.

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

Tal vez se vuelven más claras si pensamos en el nombre anidados espacios de nombres y cómo se resolvió el argumento-dependiente. La diferencia principal será implícita using en los no identificados, pero no cambiará la preferencia del compilador.