1.3.4 template and friend

• There are three different kinds for a template class: non-template friend, Bound-template, unbound-template. Below is non-template friend function counts(); The counts is not invoked by an HasFriend obj and has not object parameters. If counts want to access a HasFriend object, It can access a global one, and use a global pointer to access non-global object.
  template<typename T> 
  class HasFriend{ 
  friend void counts(); 
  }
• Bound-template friend function. You need to define explicit specialization for the friends you plan to use. Here, reports is not template function.
  template<typename T> 
  class HasFriend{ 
  friend void reports(HasFriend<T> &); 
  } 
   
  void reports(HasFriend<int> &hf){ 
  cout <<hf.item<<endl; 
  } 
  void reports(HasFriend<short> &hf){..} 
  void reports(HasFriend<char> &hf){..} 
  //explicit specialization for the type you plan to use.
• A better bound-template, reports has <> after it. and you don’t need redifne reports many time like previous codes.reports is a template function here. You can think that is a implicit instantiations.
  1) template <typename T> void report(T &); 
   
  2)template<typename TT> 
  class HasFriend{ 
  friend void reports<>(HasFriend<TT> &); 
  //it has <> after reports function name. 
  } 
   
  3) 
  template<typename T> 
  void reports(T &hf){ 
  cout <<hf.item<<endl; 
  }
• non-bound friend template.
  template<typename T> 
  class ManyFriend{ 
  template<typename C, typename D> 
    friend void show(C& , D&); 
  }; 
   
  template <typename C, typename D> void show2(c& c, D& d){ 
  cout<<c.item<<d.item<<endl; 
  } 
  ManyFriend<int> mi; 
  ManyFriend<double>md; 
  show2(mi,md);
• difference between bound and non-bound:
  1. bound friend is specialization of template function, so It has <> after the function name.
  2. non-bound template use different typename, such as C and D in previous example, and it also use template keyword
  3. bound template will produce more function implementation , but non-bound template will only produce ONE function implementation.
• Difference between template function overload and partial specializations
  1. partial specializations is just use in template class.
  2. partial specializations need put another <> after class name
  3. If you want to have custom implementation of function with same name, use overload function, if you need custom implementation of class with same name, use partial specialization.
     template <typename T1, typename T2> 
     class Pair{}  //general one 
      
     tempalte <typename T1> 
     class Pair<T1, T1>  // partial specializations 
      
     tempalte <typename T1> 
     class Pair<T1, int > // partial specializations 
     //------------------------------------------- 
      
     tempalte <typename T> 
     class Foo //general one 
      
     tempalte <typename T*> 
     class Foo //partial specializations.