1.1.11.1 overload

• To provide two (or more) functions that perform similar, closely related things, differentiated by the types and/or number of arguments it accepts.
  1. In some cases it’s worth arguing that a function of a different name is a better choice than an overloaded function.
  2. In the case of constructors, overloading is the only choice.
  3. operator overload is also very common.
• Never overload &&, || and comma in C++. Just remember it!
• Consider overloading to avoid implicit type conversion. In this way, we can avoid creating a temporary obj implicitly created by ctor.
  class String{ 
  bool operator==(const String& lhs, const String& rhs); 
  } 
  String str; 
  if(str =="hello") //will build a temp obj String("hello"); 
   
  //You can define overload to avoid implicit type conversion 
  bool operator==(const String& lhs, const char* rhs);
• overwrite is not standard conception in C++, most time, you can call it name hiding. There are two things: The first one is If you redefine the same name non-virtual function in both base and child classes, you can’t use dynamic binding, just static binding. Detail can be seen in Namespace section.
  class A{ 
      f(int) {} 
  }; 
  class B:public class A{ 
      f(int)  {} // overwrite A::f(int) 
  }; 
   
  A* pa = new B(); 
  pa->f(3) // will call base f. 
  //because pa is A* even it points to B
• A class name or enumeration name can be hidden by an explicit declaration of that same name âĂŤ as an object, function, or enumerator âĂŤ in a nested declarative region or derived class.
  //example 1 
  int x =2;{ 
    int x = 3; 
  } 
   
  //example 2; 
  void foo(int); 
  namespace X{ 
      void foo(); 
      foo(42); // will not find ‘::foo‘ 
          // because ‘X::foo‘ hides it 
  }
• If you try to overload base member function. "Name hiding" will happen. Overloading just happens in the same name scope, not in the hierarchy. So in this way, any same name is base class will not visible in derived class. You can use using keyword to add it in your derived class. Then It will compile
  class A{ 
      f(int) {} 
  }; 
  class B:public class A{ 
      using ParentClass::f; 
      // add it, you can compile your c++ code now. 
      f(char)  {} // overload A::f(int) 
  }; 
   
  B b; 
  b.f(3) // compile error. f(int) is hiding in derived class.
• Consider these complex things, Don’t redefine or overload base class non virtual functions in your child class
• Sometimes, overload and default parameter have same client usage, such as
  void f(); 
  void f(int x); 
  f() or f(10); 
   
  void g(int x = 0); 
  g() or g(10);

  If there is a value that you can use for a default, use default parameter.