c++模板與泛型編程

模板的作用：通過使用模板降低重復代碼的編寫，把已經寫好的代碼作用最大化；

模板的概念

1.模板與泛型編程（目的時只進行邏輯操作，不需要考慮數據類型，將類型作為參數傳遞）

模板是實現代碼重用的一種工具或方法，用于完成某種功能或解決某種問題，模板的作用就是實現類型參數化。

模板就是泛型編程的前置條件，屬于充分但不必要條件；

總而言之：泛型編程就是為了編寫和數據類型沒有關系的邏輯代碼，而模板就是為了實現代碼邏輯和數據類型沒有關系抽象的數據類，是泛型編程的先決條件；

2.模板分類

函數模板：

函數模板用于定義模板函數，模板函數就是用模板生成的函數；

類模板

類模板用于定義模板類，模板類就是用類模板定義出來的類；

總而言之：模板作用于函數就是函數模板，模板作用于類就是類模板；

函數模板和普通函數對比：

1.只要滿足重載條件都可以構成重載，模板函數和普通函數之間只要滿足重載條件都可以構成重載；

2.同時出現模板函數和普通函數重載，相同情況下編譯器默認優先調用普通函數；

3.如果需要強制調用模板函數，可以使用顯式調用的方式去調用指定的模板函數；

4.模板的局限性

// 通過函數模板定義模板函數
// 語法：
// 定義：
// template用于定義模板的關鍵字，typename(class)用于定義類型的關鍵字，Type_n為自定義的類型名稱
// template <typename Tpe_1, ... , typename Type_n>
// 返回值類型 函數名(形參列表)
// {
//      函數體；
// }
// 調用：
// 函數名<指定類型>(參數列表)#include <iostream>
#include <string>using namespace std;template <typename T1, typename T2>
T1 add(T1 a, T2 b)
{return a + b;
}// class也可以用于定義類型，但是一般都用typename代替class就行
template <class TT1, class TT2>
void test1(TT1 tt1, TT2 tt2)
{cout << "tt1 = " << tt1 << ", tt2 = " << tt2 << endl;
}// class也可以用于定義類型，但是一般都用typename代替class就行
template <typename TY1, typename TY2>
void test2(TY1 tt1, TY2 tt2)
{cout << "tt1 = " << tt1 << ", tt2 = " << tt2 << endl;
}int main()
{// test1// 隱式推導類型，由編譯器指定cout << "test1 : " << endl;test1(1, 2);test1(1.123, 2.123);test1("name", 'A');// test2cout << "test2 : " << endl;test2(1, 2);test2(1.123, 2.123);test2("name", 'A');// add測試cout << "add(3, 4) = " << add(3, 4) << endl;cout << "add(1.23, 1.24) = " << add(1.23, 1.24) << endl;// add(6, 2.46) = 8 輸出的數據類型由編譯器決定，這里返回值設置為int類型cout << "add(6, 2.46) = " << add(6, 2.46) << endl;cout << "add<int>(6, 2.46) = " << add<int>(6, 2.46) << endl;cout << "add<double>(6, 2.46) = " << add<double>(6, 2.46) << endl;// 模板函數調用，顯式指定類型，告訴編譯器按照指定類型操作// const char *就是string類型test1<const char *, char>("name", 'A');return 0;
}

// 模板的局限性
#include <iostream>
#include <string>using namespace std;template <typename T>
bool IsDataEqual(T a, T b)
{if (a == b) {return true;}return false;
}class MyData
{
public:int m_num;int m_val;// 添加默認構造函數，如果有自定義構造函數后系統將不會再分配默認的構造函數// 如果沒有沒有這個無參構造函數，那么通過MyData obj1, obj2;方式定義對象時會報錯如下：// error: no matching function for call to ‘MyData::MyData()’MyData obj1, obj2;MyData() : m_num(0) {}// 自定義帶參構造函數MyData(int n) : m_num(n) {}
};class MyClass
{
public:int m_num;int m_val;// 如果加上設置默認缺省參數值，可以使用MyClass obj創建對象，此時這個對象擁有設置的默認缺省參數值MyClass(double n = 5.0, double val = 6.0) : m_num(n), m_val(val) {}
};// 對自定義數據類型的對象需要自定義規則進行比較
template<typename TT> bool MyCompare(const TT &a, const TT &b)
{if (a.m_num == b.m_num) {return true;}return false;
} int main()
{int num = 5, val = 5;cout << boolalpha << IsDataEqual(num, val) << endl;val = 6;cout << (IsDataEqual(num, val) ? "true" : "false") << endl;cout << (IsDataEqual<int>(num, val) ? "true" : "false") << endl;// 自定義數據類型比較MyData obj1(5), obj2(5);// 如果沒有重載==運算符，不同對象之間不可以使用模板函數進行比較cout << (MyCompare(obj1, obj2) ? "true" : "false") << endl;cout << (MyCompare<MyData>(obj1, obj2) ? "true" : "false") << endl;MyClass obj;cout << "obj.m_num = " << obj.m_num << ", obj.m_val = " << obj.m_val << endl;return 0;
}

// 模板類
// 語法：
// template<類型參數列表>
// class 模板類類名
// {
//     成員;
// }; // 定義域需要加";"// 類型參數列表：<class T1, ..., class Tn>
// 成員：T1 name; ... Tn#include <iostream>
#include <string>using namespace std;// 數據參數可用默認值，數據類型也可以使用默認值
// 默認類型可以有，也可以不寫
// template <class Type1 = int, class Type2 = double>
template <class Type1, class Type2>
class MyData
{
private:Type1 m_num;Type2 m_val;
public:MyData(Type1 n = 0, Type2 v = 0.0) : m_num(n), m_val(v) {}// get/set 內聯Type1 GetNum() {return m_num;}Type2 GetVal() {return m_val;}void SetNum(Type1 n) {m_num = n;}void SetVal(Type2 v) {m_val = v;}void showData();
};// 模板類需要給定類型才能完整，沒給類型就不是完整類
template <typename T1, typename T2>
void MyData<T1, T2>::showData()
{cout << "num = " << m_num << ", val = " << m_val << endl;
}// 1.普通全局函數
// 普通全局函數，指定MyData類型的對象并指定模板類對象的參數
// 這種寫法只能接收類型匹配的參數對象
void testFunc_1(MyData<int, double> &obj)
{cout << "testFunc_1(MyData<int, double> &obj) : " ;obj.showData();
}// 2.函數參數模板化
template <typename TT1, typename TT2>
void testFunc_2(MyData<TT1, TT2> & obj)
{cout << "testFunc_2(MyData<TT1, TT2> & obj)  : " ;obj.showData();
}// 3.整個類作為一個類型,整體參數作為一個模板傳輸
template <class T>
void testFunc_3(T & obj)
{cout << "testFunc_3(T & obj)  : " ;obj.showData();
}int main()
{// 如果沒有設置默認參數類型則需要指定參數類型// template <class Type1, class Type2> // 未指定默認參數類型MyData<int, double> data_1(3, 3.14);testFunc_1(data_1);// 如果有設置默認參數類型，<>中可以不指定數據類型// template <class Type1 = int, class Type2 = double> // 指定默認參數類型// MyData<> data_1(3, 3.14);data_1.showData();// 模板類可以在創建對象的時候指定對象中的類型MyData<char, double> data_2(67, 3.14);data_2.showData();// 隱式調用，不指定參數類型testFunc_2(data_2);// 顯示調用，指定參數類型testFunc_2<int, double>(data_1);MyData<char, float> data_3(68, 3.14);data_3.showData();// 通過以上測試可以看出同一種類型的對象數據類型不一樣，這就是模板類的功能testFunc_3(data_1);testFunc_3<MyData<int, double>>(data_1);testFunc_3(data_2);testFunc_3<MyData<char, double>>(data_2);testFunc_3(data_3);testFunc_3<MyData<char, float>>(data_3);return 0;
}

// 類模板的繼承
// 注意事項：
// 寫模板時需要將類的聲明和實現都寫在同一個文件中
#include <iostream>
#include <string>using namespace std;template <class FType>
class Father
{
public:FType m_f_val;
};// 子類繼承父類時需要指定參數類型
class Son : public Father<int>
{
public:int m_s_val;
};// 子類本省也可以是一個模板
template <class SType1, class SType2>
class Son1 : public Father<SType1>
{
public:int m_s_val;
};int main()
{Son1<int, double> obj_son;obj_son.m_f_val;obj_son.m_s_val;return 0;
}

// 模板與友元之間的關系
// 相當于就是在類模板中使用友元函數
#include <iostream>
#include <string>using namespace std;// 模板類友元函數能不用就不用，
// 如果非得要用，在類中聲明時需要在函數名后邊加上一個<>,實現函數體定義的時候不能在函數名后邊加<>
// 需要在模板類友元函數前面先聲明類
// 還需要在模板類友元函數前面聲明函數
// 以下4行聲明代碼其實只需要先聲明void show_2(A<T> & obj);函數即可
// 但是void show_2(A<T> & obj);函數聲明的時候需要聲明類型T,即template <typename T>
// template <typename T>聲明類型T的時候發現類A也需要提前聲明
// class A;聲明類A的時候也得提前聲明模板類型，即template <class T>
// 所以就有了以下4行聲明
template <class T>
class A;
template <typename T>
void show_2(A<T> & obj);// 只設置一個類型，并設置默認參數類型為int，當然也可以不設置默認類型
template <class T = int>
class A
{
public:A(T t = 0) : m_a(t) {}private:T m_a;// C++ 中友元函數 `friend` 的權限與其在類中聲明的訪問權限是無關的，// 即無論它是在 `public`、`protected` 或 `private` 聲明的，它的訪問權限都是類外的，可以訪問類的私有成員。// 當在類中聲明一個函數為 `friend`，其實質上是將這個函數的訪問權限放寬到了類的外部，使它可以訪問類的私有成員。// 因此，友元函數的訪問權限不受類的訪問控制修飾符所限制。// 需要注意的是，友元關系是單向的，即如果類 A 作為類 B 的友元，不一定意味著類 B 作為類 A 的友元。// 另外，友元關系是不能被繼承的，即派生類無法訪問基類中的友元函數。friend void show_1(A<T> & obj) {cout << "show_1() : " << obj.m_a << endl;}// 其實友元函數一般只在類中聲明，類外定義// show_2中的T與上文中的T沒有任何聯系，巧合，都稱之為T// 只有在聲明的時候需要在函數名后邊寫<>，在實現定義的時候不需要加<>friend void show_2<>(A<T>& obj);};template <typename T>
// 只有在聲明的時候需要在函數名后邊寫<>，在實現定義的時候不需要加<>
void show_2(A<T> & obj)
{cout << "show_2() : " << obj.m_a << endl;
}int main()
{A<int> obj_a(666);show_1(obj_a);show_2(obj_a);return 0;
}