template <typename T> // typename和class一样的 
T function(T* p) 
{ 
  T tmp = *p;  // 临时变量类型为T 
  //... 
  return tmp;  // 返回值类型为T 
} 

int a = 10; 
cout << function(&a) << endl;   // 编译器根据函数实参推断模板实参 
 
cout << function<int>(&a) << endl;  // <int>指出模板参数为int 

// 整形模板 
template<unsigned M, unsigned N> 
void add() 
{ 
  cout<< M+N << endl; 
} 
 
// 指针 
template<const char* C> 
void func1(const char* str) 
{ 
  cout << C << " " << str << endl; 
} 
 
// 引用 
template<char (&R)[9]> 
void func2(const char* str) 
{ 
  cout << R << " " << str << endl; 
} 
 
// 函数指针 
template<void (*f)(const char*)> 
void func3(const char* c) 
{ 
  f(c); 
} 
 
void print(const char* c) { cout << c << endl;} 
 
char arr[9] = "template";  // 全局变量，具有静态生存期 
 
int main() 
{ 
  add<10, 20>(); 
  func1<arr>("pointer"); 
  func2<arr>("reference"); 
  func3<print>("template function pointer"); 
  return 0; 
} 

template<typename T> 
class Array { 
public: 
  Array(T arr[], int s); 
  void print(); 
private: 
  T *ptr; 
  int size; 
}; 
 
// 类模板外部定义成员函数 
template<typename T> 
Array<T>::Array(T arr[], int s) 
{ 
  ptr = new T[s]; 
  size = s; 
  for(int i=0; i<size; ++i) 
    ptr[i]=arr[i]; 
} 
 
template<typename T> 
void Array<T>::print() 
{ 
  for(int i=0; i<size; ++i) 
    cout << " " << *(ptr+i); 
  cout << endl; 
} 
 
int main() 
{ 
  char a[5] = {'J','a','m','e','s'}; 
  Array<char> charArr(a, 5); 
  charArr.print(); 
 
  int b[5] = { 1, 2, 3, 4, 5}; 
  Array<int> intArr(b, 5); 
  intArr.print(); 
 
  return 0; 
}

template <typename T> 
return_type class_name<T>::member_name(parm-list) { } 

// 前置声明，在将模板的一个特定实例声明为友元时要用到 
template<typename T> class Pal; 
 
// 普通类 
class C { 
  friend class Pal<C>; // 用类C实例化的Pal是C的一个友元 
  template<typename T> friend class Pal2; //Pal2所有实例都是C的友元;无须前置声明 
}; 
 
// 模板类 
template<typename T> class C2 { 
  // C2的每个实例将用相同类型实例化的Pal声明为友元,一对一关系 
  friend class Pal<T>; 
  // Pal2的所有实例都是C2的每个实例的友元，不需要前置声明 
  template<typename X> friend class Pal2;  
  // Pal3是普通非模板类，它是C2所有实例的友元 
  friend class Pal3; 
}; 

template<typename T> 
class Foo { 
public: 
  void print(); 
  //...其他操作 
private: 
  static int i; 
}; 
 
template<typename T> 
void Foo<T>::print() 
{ 
  cout << ++i << endl; 
} 
 
template<typename T> 
int Foo<T>::i = 10; // 初始化为10 
 
int main() 
{ 
  Foo<int> f1; 
  Foo<int> f2; 
  Foo<float> f3; 
  f1.print();  // 输出11 
  f2.print();  // 输出12 
  f3.print();  // 输出11 
  return 0; 
}