C++中的數(shù)據(jù)類模板

　　1，預(yù)備知識：

　　1，模板參數(shù)可以是數(shù)值型參數(shù)(非類型參數(shù))：

　　1，代碼示例：

　　1 template

　　2 void func()

　　3 {

　　4 T a[N]; // 使用模板參數(shù)定義局部數(shù)組;

　　5 }

　　6

　　7 func(); // 使用模板時，數(shù)值型參數(shù)必須是常量，不能是變量;

　　2，數(shù)值型模板參數(shù)的限制：

　　1，變量不能作為模板參數(shù);

　　1，是變量的話就不滿足準確確定的這個本質(zhì);

　　2，浮點數(shù)不能作為模板參數(shù);

　　1，浮點數(shù)本身不精確;

　　3，類對象不能作為模板參數(shù);

　　1，類對象編譯時不能唯一確定的，同變量一樣;

　　3，數(shù)值型參數(shù)本質(zhì)：模板參數(shù)是在編譯階段被處理的單元，因此，在編譯階段必須準確無誤的唯一確定;

　　2，有趣的面試題：

　　1，用你覺得最高效的方法求 1 + 2 + 3 + ... + N 的值;

　　1，等差數(shù)列和的方式;

　　2，見下面實例;

　　3，數(shù)值型模板參數(shù)編程實驗：

　　1 #include

　　2 #include

　　3

　　4 using namespace std;

　　5

　　6 /* 驗證上面的預(yù)備知識 */

　　7 template

　　8 < typename T, int N > // 這里用成 double 后，編譯器顯示：error: 'double' is not a valid type for a template constant parameter

　　9 void func()

　　10 {

　　11 T a[N] = {0};

　　12

　　13 for(int i=0; i

　　14 {

　　15 a[i] = i;

　　16 }

　　17

　　18 for(int i=0; i

　　19 {

　　20 cout << a[i] << endl;

　　21 }

　　22 }

　　23

　　24 /* 用最高效的方法驗證從 1 加到 n 的和;不用循環(huán)和等差數(shù)列求和公式 */

　　25 template

　　26 < int N >

　　27 class Sum

　　28 {

　　29 public:

　　30 // static const int VALUE = 0; // static 后是想定義常量，被 static 修飾后要么放入符號表、要么放到全局數(shù)據(jù)區(qū); 這個時候 VALUE 已經(jīng)確定了值，所以直接進入符號表(符號表存儲在哪里呢);又因為 VALUE 被 static 修飾了，所以 VALUE 被放入全局數(shù)據(jù)區(qū);

　　31 static const int VALUE = Sum::VALUE + N; // 遞歸定義

　　32 };

　　33

　　34 /* 定義上述模板類的特化實現(xiàn)，實現(xiàn)遞歸出口 */

　　35 template

　　36 < >

　　37 class Sum < 1 >

　　38 {

　　39 public:

　　40 static const int VALUE = 1;

　　41 };

　　42

　　43 int main()

　　44 {

　　45 func(); // 打印 0 到 9 這十個數(shù)字;這里如果模板參數(shù)類型為 double，編譯器顯示：error: no matching function for call to 'func()';

　　46

　　47 int a = 10;

　　48 func(); // 在這一行編譯器顯示：

　　49 // error: 'a' cannot appear in a constant-expression

　　50 // error: no matching function for call to 'func()'

　　51

　　52 cout << "1 + 2 + 3 + ... + 10 = " << Sum<10>::VALUE << endl; // 55;這里沒有加減乘除法，也沒有函數(shù)調(diào)用和循環(huán)，這里VALUE 是常量，并在編譯的時候已經(jīng)確定，這里效率是最高的;

　　53 cout << "1 + 2 + 3 + ... + 100 = " << Sum<100>::VALUE << endl; // 5050

　　54

　　55 return 0;

　　56 }

　　1，這里的相加求和是在編譯器編譯程序的時候完成的，編譯完程序后，要求的和的值已經(jīng)確定，在運行的時候，就直接可以訪問這個值，不需要做任何的運算和循環(huán)，因此效率最高;

　　2，這個最高效的求和依賴了模板技術(shù)、模板特化技術(shù)、數(shù)值型模板參數(shù)技術(shù);

　　3，可以舉一反三，得到更多高效的程序?qū)懛?

　　4，數(shù)組模板類編程實驗：

　　1，Array.h 文件：

　　1 #ifndef _ARRAY_H_ // 防止多次包含頭文件;

　　2 #define _ARRAY_H_

　　3

　　4 template

　　5 < typename T, int N > // 數(shù)組元素的類型和大小;

　　6 class Array

　　7 {

　　8 T m_array[N]; // 定義一個實際的數(shù)組;

　　9 public:

　　10 int length();

　　11 bool set(int index, T value);

　　12 bool get(int index, T& value);

　　13 T& operator[] (int index);

　　14 T operator[] (int index) const; // 數(shù)組類對象有可能是 const 對象，這個時候就只能調(diào)用 const 函數(shù)，所以要定義這個;const 函數(shù)只能返回值，不能返回引用;

　　15 virtual ~Array(); // 有可能被繼承

　　16 };

　　17

　　18 /* 模板類要放在一個文件中，所以實現(xiàn)在下面實現(xiàn) */

　　19

　　20 template

　　21 < typename T, int N >

　　22 int Array::length()

　　23 {

　　24 return N;

　　25 }

　　26

　　27 template

　　28 < typename T, int N >

　　29 bool Array::set(int index, T value)

　　30 {

　　31 bool ret = (0 <= index) && (index < N);

　　32

　　33 if( ret )

　　34 {

　　35 m_array[index] = value;

　　36 }

　　37

　　38 return ret;

　　39 }

　　40

　　41 template

　　42 < typename T, int N >

　　43 bool Array::get(int index, T& value)

　　44 {

　　45 bool ret = (0 <= index) && (index < N);

　　46

　　47 if( ret )

　　48 {

　　49 value = m_array[index];

　　50 }

　　51無錫婦科費用 http://www.wxbhnkyy39.com/

　　52 return ret;

　　53 }

　　54

　　55 template

　　56 < typename T, int N >

　　57 T& Array::operator[] (int index)

　　58 {

　　59 return m_array[index];

　　60 }

　　61

　　62 template

　　63 < typename T, int N >

　　64 T Array::operator[] (int index) const

　　65 {

　　66 return m_array[index];

　　67 }

　　68

　　69 template

　　70 < typename T, int N >

　　71 Array::~Array()

　　72 {

　　73

　　74 }

　　75

　　76 #endif

　　5，小結(jié)：

　　1，模板參數(shù)可以是數(shù)值型參數(shù);

　　2，數(shù)值型模板參數(shù)必須在編譯期間唯一確定;

　　3，數(shù)組類模板是基于數(shù)值型模板參數(shù)實現(xiàn)的;

　　4，數(shù)組類模板是簡易的線性表數(shù)據(jù)結(jié)構(gòu);