1.1.8.3 name hiding

• Function name resolution:
  1. First, it looks in the immediate scope, and makes a list of all functions it can find that has right named (regardless of whether they’re accessible or even take the right number of parameters). If name and type mismatch, compiler will bark.
  2. Only if it doesn’t find any at all does it then continue "outward" into the next enclosing scope and repeat.
  3. If in searching scope there are more than one candidate functions, the compiler then stops searching and works with the candidates that it’s found, performing overload resolution and then applying access rules.
  4. overload resolution will not go across scopes!
• There are three examples about immediate scope.
  1. class scope:
     void f1(int i ){...}; 
      
     class Foo{ 
     void f1(string & str){}; 
     void f2(void){ 
     int i = 3; 
     f1(i); //here. 
     } 
     };
  2. Child class scope: In child class scope, if it found name g, then it will stop looking for another name in outward scope. just use g, then found argument number is not match, then compiler bark.
     struct B{ 
     int f( int ); 
     int f( double ); 
     int g( int ); 
     }; 
     struct D : public B{ 
     private: 
     int g( std::string, bool ); 
     }; 
     D d; 
     int i; 
     d.f(i); // ok, means B::f(int) 
     d.g(i); // error: g takes 2 args
  3. Nested namespace scope. (global includes namespace N)
     void f1(int i ){...}; 
      
     namespace N{ 
     void f1(string & str){}; 
     void f2(void){ 
     int i = 3; 
     f1(i); //here. 
     } 
     };
• How to resolve it. There are two methods:
  // method 1; 
  D d; 
  int i; 
  d.f(i); // ok, means B::f(int) 
  ______d.B::g(i); // ok, asks for B::g(int) 
   
  // method 2: 
  struct D : public B{ 
  _______________using B::g; 
  private: 
  int g( std::string, bool ); 
  };