1.1.8.2 name lookup

• Koenig(ADL) lookup: If you supply a function argument of class type (here x, of type A::X), then to look up the correct function name the compiler considers matching names in the namespace (here A) containing the argument’s type.
  namespace NS{ 
  class T { }; 
  void f(T); 
  } 
   
  NS::T parm; 
  int main() { 
  f(parm); // OK, calls NS::f 
  }
• ADL can bring name loopup ambiguous problem. When you call f(parm) f is in global scope, So number 2 is in the searching scope default. But ADL bring namesapce NS scope into searching scope. In searching scope, there are two options, so compiler will stop.
  namespace NS { // some header T.h 
  class T { }; 
  void f( T ); //  number 1, add new function 
  } 
  void f( NS::T ); //number 2 
  int main(){ 
  NS::T parm; 
  f(parm); // ambiguous: NS::f  or global f? 
  }
• Just like previous example, g is in the namespace B, with help of ADL, searching scope is namespace A+ namespace B. there are tow f in the searching scope.
  namespace A{ 
  class X { }; 
  void f( X ); // <-- new function 
  } 
  namespace B{ 
  void f( A::X ); 
  void g( A::X parm ){ 
  f(parm); // ambiguous: A::f or B::f? 
  } 
  }
• In name lookup, the C++ language deliberately says that a member function is to be considered more strongly related to a class than a nonmember.
  namespace A{ 
  class X { }; 
  void f( X ); 
  } 
   
  class B // <-- class, not namespace{ 
  void f( A::X ); 
  void g( A::X parm ){ 
  f(parm); // OK: B::f, not ambiguous 
  } 
  };
• For a class X, all functions, including free functions, that both "Mention" X and "supplied with" X are logically part of X, because they form part of the interface of X.
• Keep a type and its nonmember function interface in the same namespace, 1) in logic, these nonmember function can be regarded as type interface, 2) avoid name ambigous problem in the future.
  namespace N{ 
  class X {}; 
   
  X operator+( const X&, const X& ); 
  } 
   
  x3 = x1+x2;
• Keep types and functions in separate namespaces unless they’re specifically intended to work together
  #include <vector> 
  namespace N { 
  struct X {}; 
   
  // this template should not be put in the namespace N 
  template<typename T> 
  int* operator+( T , unsigned ) {/* do something */} 
  }