一、類模板的引出：

1、在c++中是否能夠將泛型的思想應用在類上呢？

我們在前面的兩篇文章里面，對函數模板有了一個清楚的認識，作為類比學習，當然泛型的思想是可以應用到類上的。

2、類模板：

• 一些類主要用于存儲和組織數據元素

• 類中數據組織的方式和數據元素的具體類型無關

• 如：數組類，鏈表類，Stack類，Queue類等等

• c++中將模板的思想應用于類，使得類的實現不關注數據元素的具體類型，而只關注類所需要實現的功能

3、C++中的模板：

以相同的方式處理不同的類型

在類聲明前使用template進行標識

template < typename T >//T表示泛指類型

class Operator
{
   public:
      T op(T a , T b);
};

4、類模板的應用

• 只能顯示指定具體類型，無法自動推導（我們的函數模板是可以實現自動推導具體類型的）

 //使用具體類型"<Type>"定義對象
Operator<int> op1;
Operator<string> op2;

int i = op1.op(1,2);
string s = op2.op("txp","C++");
  

• 聲明的泛指類型T可以出現在類模板的任意地方

• 編譯器對類模板的處理方式和函數模板相同

-從類模板通過具體類型產生不同的類

-在聲明的地方對類模板代碼本身進行編譯

-在使用的地方對參數替換后代碼進行編譯

代碼實踐：

#include <iostream>
#include <string>

using namespace std;

template < typename T >
class Operator
{
public:
    T add(T a, T b)
    {
        return a + b;
    }
    T minus(T a, T b)
    {
        return a - b;
    }
    T multiply(T a, T b)
    {
        return a * b;
    }
    T divide(T a, T b)
    {
        return a / b;
    }
};

string operator-(string& l, string& r)// 全局函數方式重載 - 操作符，編譯通過；先類內部、再全局
{
    return "Minus";
}

int main()
{
    Operator<int> op1;
    
    cout << op1.add(1, 2) << endl;
    
    Operator<string> op2; // 第二次使用類模板時進行編譯，但是并不是對所有模板中的函數進行了第二次編譯，是分步編譯的，首先編譯的是構造函數，此時用的是默認的，沒有問題，這里編譯通過；
    
    cout << op2.add("Txp", "C++") << endl;
    cout << op2.minus("Txp", "C++") << endl; // 如果沒有定義全局的重載 - 操作符的函數時，字符串相減沒有定義，報錯；這里報錯展示出來是為了證明類模板編譯也是經過了兩次編譯；這里編譯器針對 minus() 函數進行第二次編譯；定義全局的重載 - 操作符函數后，打印 Minus ；
    
    return 0;
}

輸出結果：

root@txp-virtual-machine:/home/txp# ./a.out
3
TxpC++
Minux

5、類模板的工程應用

• 類模板必須在頭文件中定義

• 類模板不能分開實現在不同的文件中

• 類模板外部定義的成員函數需要加上模板<>聲明

代碼實踐：

Operator.h頭文件：

#ifndef _OPERATOR_H_
#define _OPERATOR_H_

template < typename T >
class Operator
{
public:
    T add(T a, T b);
    T minus(T a, T b);
    T multiply(T a, T b);
    T divide(T a, T b);
};

template < typename T >
T Operator<T>::add(T a, T b)
{
    return a + b;
}


template < typename T >
T Operator<T>::minus(T a, T b)
{
    return a - b;
}


template < typename T >
T Operator<T>::multiply(T a, T b)
{
    return a * b;
}


template < typename T >
T Operator<T>::divide(T a, T b)
{
    return a / b;
}

#endif

test.cpp文件：

#include <iostream>
#include <string>
#include "Operator.h"

using namespace std;


int main()
{
    Operator<int> op1;
    
    cout << op1.add(1, 2) << endl;
    cout << op1.multiply(4, 5) << endl;
    cout << op1.minus(5, 6) << endl;
    cout << op1.divide(10, 5) << endl;
    
    return 0;
}

輸出結果：

root@txp-virtual-machine:/home/txp# ./a.out
3
20
-1
2