模板就是實現程式碼重用機制的一種工具，它可以實現型別引數化，即把型別定義為引數， 從而實現了真正的程式碼可重用性。模版可以分為兩類，一個是函式模版，另外一個是類模版。

函式模板

函式模板的一般寫法:

template <class T>
返回型別 函式名（形參表）{
//函式主體
}

或者

template <typename T>
返回型別 函式名（形參表）{
//函式主體
}

template是一個宣告模板的關鍵字，表明一個模板關鍵字的class或typename不能省略，來看一個具體例子

#include <iostream>
#define SQUARE(X) X*X
 

using namespace std;

inline double square(double x);
template <class T>
T MinNum(T x, T y){
    return (x<y?x:y);
}

int main() {
    double a,b,c;
    int x,y;
    x = 3;
    y = 10;
    a = square(5.0);
    b = square(2.2+1.1);
    c = SQUARE(2.2+1.1);
    cout << a  << endl;
    cout <<
 
 b << endl;
    cout << c << endl;
    cout << MinNum(a, b) << endl;
    cout << MinNum(x, y) << endl;
    return 0;
}

inline double square(double x){
    return x*x;
}

程式分析：程式中定義了雙精度浮點型別變數a,b。 定義了整型變數x,y。在比較大小時同都使用MinNum(T x, T y)函式。例項化MinNum(a,b)是T為double型，例項化MinNum(x,y)時 T為int 型

類模板

類模板的一般形式如下：

Template <class T>
class 類名{
//類定義
}

其中，template是宣告各模板的關鍵字，表示宣告一個模板，模板引數可以是一個，也可以是多個。

例如：定義一個類模板：

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>
 
using namespace std;
 
template <class T>
class Stack { 
  private: 
    vector<T> elems;     // 元素 
 
  public: 
    void push(T const&);  // 入棧
    void pop();               // 出棧
    T top() const;            // 返回棧頂元素
    bool empty() const{       // 如果為空則返回真。
        return elems.empty(); 
    } 
}; 
 
template <class T>
void Stack<T>::push (T const& elem) 
{ 
    // 追加傳入元素的副本
    elems.push_back(elem);    
} 
 
template <class T>
void Stack<T>::pop () 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::pop(): empty stack"); 
    }
    // 刪除最後一個元素
    elems.pop_back();         
} 
 
template <class T>
T Stack<T>::top () const 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::top(): empty stack"); 
    }
    // 返回最後一個元素的副本 
    return elems.back();      
} 
 
int main() 
{ 
    try { 
        Stack<int>         intStack;  // int 型別的棧 
        Stack<string> stringStack;    // string 型別的棧 
 
        // 操作 int 型別的棧 
        intStack.push(7); 
        cout << intStack.top() <<endl; 
 
        // 操作 string 型別的棧 
        stringStack.push("hello"); 
        cout << stringStack.top() << std::endl; 
        stringStack.pop(); 
        stringStack.pop(); 
    } 
    catch (exception const& ex) { 
        cerr << "Exception: " << ex.what() <<endl; 
        return -1;
    } 
}

當上門的程式碼被編譯和執行時，產生如下結果

7
hello
Exception: Stack<>::pop(): empty stack

模板與過載的區別

1. 從程式碼中我們可以學習到，模板的定義方式一般有兩種，分別為：template < typename T> 或 template 。有人可能會問一個typename和一個class這裡面有什麼區別，其實早期的C++並沒有typename這個關鍵字，所以不論是函式模板還是類模板，都使用class的這種定義方式，後面C++完善，於是多出了typename，用來區分定義的是函式模板還是類模板，但本質都是一樣的。

2. 所謂的函式模板，實際上是建立一個通用的函式，其函式的型別和形參的型別不具體指定，用一個虛擬的型別來代表，這個通用的函式就成為函式模板。凡是函式體相同的函式都可以用這個模板來代替，而不必定義多個函式，只需在模板中定義一次就行了，在呼叫函式的時候系統會根據實參的型別來取代模板中的虛擬型別，從而實現了不同函式的功能。

3. 相對於函式過載而言，模板具有得天獨厚的優勢，它不需要重複定義，所以使用起來比函式過載更簡潔，但應注意的一點，函式模板只適用於函式的引數個數相同而型別不同，且函式體相同的情況，如果引數的個數不同，則不能用函式模板，這就是函式模板相對於函式過載的缺陷。

一個函式過載的例子如下：

#include <iostream>
using namespace std;
 
class printData
{
   public:
      void print(int i) {
        cout << "整數為: " << i << endl;
      }
 
      void print(double  f) {
        cout << "浮點數為: " << f << endl;
      }
 
      void print(char c[]) {
        cout << "字串為: " << c << endl;
      }
};
 
int main(void)
{
   printData pd;
 
   // 輸出整數
   pd.print(5);
   // 輸出浮點數
   pd.print(500.263);
   // 輸出字串
   char c[] = "Hello C++";
   pd.print(c);
 
   return 0;
}