1.3.3 overload resolution

• Given a function name, you can have regular, template and explicit specialization temple. When pick a function, regular> specialization> template. function picking ranking from best to worst is:
  1. Exact math, regular function
  2. Template if you have define the same template function name.
  3. Conversion by promotion
  4. Conversion by standard conversion.
  5. user-defined conversion.s
• What is exact match. There are table below:

  Actual argument	Formal argument
  type-name	type-name &
  type-name &	type-name
  type-name [ ]	type-name*
  type-name ( argument-list )	( *type-name ) ( argument-list )
  type-name	const type-name
  type-name	volatile type-name
  type-name*	const type-name*
  type-name*	volatile type-name*

• About exact match, there are three result:
  1. If there are two exact matches, compiler can’t distinguish them, then it will report error
  2. If reference and pointer, even there are two exact match, It will pick up first according to const.
     int i = 2; 
      
     f(const int& j); //#1 
     f(int& j);  //#2, 2 will be selected, because i isn’t const
  3. If there are exact match, it will pick up before template, even template has EXACT specification.
• For temple, order is:
  1. specialized argument template
  2. specialization version in side this specialized argument template.
  template<typename T> 
  f(T t);  //#1 
  template< >f<int*>(int* t) #2 
   
  template<typename T> 
  f(T* t); //#3 
   
  template<> f<int> f( int* t) //#4 
   
  int * p; 
  f(p) // #4>#3>#2>#1
• For above example, If you omit type inside <> after function name f, It will depends on location.
  template<typename T> 
  f(T t);  //#1 
   
  template< >f<>(int* t) //#2 is specialization of #1 
  ///////////////////////////////////////// 
  template<typename T> 
  f(T* t); //#3 
   
  template< >f<>(int* t) //put here is specialization of #3
• You can tell compiler that you prefer template function over overload one
  template<typename T> 
  void f(T t);  //#1 
   
  void f(int t) //#2 
   
  f<>(2) //tell compiler use #1, not #2.