This article is for reading of C++ Templates The Complete Guide.
 
1 Define a function template:
template <typename T>
inline T const& max (T const& a, T const& b)
{
   return a<b?b:a;
}
As seen in this example, template parameters must be announced with syntax of the following form:
template < comma-separated-list-of-parameters >, the keyword typename introduces a so-called type parameter.

2 Calling to a function template:
int i = 42;
std::cout << "max(7,i): " << ::max(7,i) << std::endl;
double f1 = 3.4;
double f2 = -6.7;
std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl;
std::string s1 = "mathematics";
std::string s2 = "math";
std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl;
Normally, templates aren't compiled into single entities that can handle any type. Instead, different entities are generated from the template for every type for which the template is used.


3 Note that no automatic type conversion is allowed here. Each must match exactly. For example:
template <typename T>
inline T const& max (T const& a, T const& b);
…
max(4,7) // OK: T is int for both arguments
max(4,4.2) // ERROR: first T is int, second T is double
There are three ways to handle such an error:
Cast the arguments so that they both match: max(static_cast<double>(4),4.2) // OK
Specify (or qualify) explicitly the type of T: max<double>(4,4.2) // OK

4 Class template usage:

template <typenameTarget>
class Singleton
{
public:
static Target* Instance() //Static template member function should be impleted in the define of template
{                                       //notes: it is not a thread safe
 if (m_pInstance==NULL)
  m_pInstance = new Target();

 return m_pInstance;
}

protected: //!!set the constructor and destructor to be protected to avoid unnecessary intance
 Singleton(); // constructor
 ~Singleton(); // destructor
private:
 static  Target* m_pInstance;
};

//static class member initialisation should be global
template <typename Target>
Target* Singleton<Target>::m_pInstance = NULL;

int main(int argc, _TCHAR* argv[])
{
 int* testSingle = Singleton<int>::Instance();
 std::cout<<*testSingle<<std::endl;
}

4.1 Nontype Class Template Parameters
Notype parameter provides a special way to define the property of template. But you cannot use floating-point numbers, class-type objects, and objects with internal linkage (such as string
literals) as arguments for nontype template parameterstemplate <typename T, int MAXSIZE>
class Stack {
private:
T elems[MAXSIZE]; // elements
int numElems; // current number of elements
}
Stack<int,20> int20Stack; // stack of up to 20 ints

6.1 The way that including declare and implemention of template in the header file is inclusion model. This kind of model is popular in the development. 
7.1 The process of creating a regular class, function, or member function from a template by substituting actual values for its arguments is called template instantiation. This resulting entity (class, function, or member function) is generically called a specialization.