1.1.17.1 Template basic

• A simple way to simulate template is typedef int Item; But when you change the data type, you need to change header file, and you can’t have int and double to template class at the same programme. so C++ introduces a better method: template<typename T>.
• You should use templates if you need functions or container class(act likes) that apply the same algorithm to a variety of types. Templates are frequently used for container classes because the idea of type parameters matches well with the need to apply a common storage plan to a variety of types.
• Use typename , not class. At the same time. simple names, such as T.
  template<typename T> swap(T& a, T&b){ 
  ......... 
  }
• template can’t be compiled. only when you declare a variable, It will instantiation. (It will make compiling time longer). So all the template definition must be put in head file.
• template class can be used as base class and used as a component class
  template< typename Type> 
  class SpecialStack: public Stack<Type>{ 
  Array<Type> array; 
  }
• You can use more than one type parameter, or Default Type Template Parameters
  template <typename T1,  typeName T2> 
  class Pair{ } 
  Pair<double, int> pair1; 
   
  template <typename T1,  typeName T2=int> 
  class Pair{ } 
  Pair<double> pair2;
• you can use Non-Type Argument in a template
  template <typename T, int n> 
  class ArrayTP{ 
  T ar[n]; 
  ...... 
  }
• C++ use implicit or explicit instantiation to generate a specialized class or function definition from template For implicit, you have to declare an obj, but for explicit, you don’t need to declare an obj;
  ArrayTP<int, 100> stuff //implicit instantiation 
  // you have to declare obj stuff. 
   
  template ArrayTP<string, 100>; 
  //generate a specialized class even you don’t declare an obj
• Explicit Specialization: Because for char *, you can’t use > , but use strcmp. So you need to build explicit Specialization Version. The prototype and definition of an explicit spcialization should be preceded by template<> and should mention the specialized type by name.
  Template<typename T> 
        void sortedArrary(T) {...}; 
   
  template<> void sortedArray<const char *>(){...}
• Explicit include complete specialization and partial specialization.
  template<> class Pair<int,int>{...}; //complete specialization 
  template<typename T1> class Pair<T1, int>{...}; //Partial
• Non type argument and default type argument only define one template body(only one recipe). But Specialization need to define a generic template body(one recipe), For another type, It need to define a different template body(another recipe), because the code will be different with generic one.

  Instantiation is different with specialization. For instantiation, it will use template function to produce function body, but for specializaiton, you have to redefine you own function body

  Template<typename T> 
        void sortedArrary (T) {...}; 
   
  template void sortedArray<Person>(Person) // instantiation 
  template<> void sortedArray<Person>(Person){ // specialization. 
  .... //give you own definition of fun body. 
  };
• keep the design of a template in mind and not use it blindly. When you input pointer as typename, you should be on high alert.