C++中的數據類模板

1，預備知識：

    1，模板參數可以是數值型參數（非類型參數）：

       1，代碼示例：

template <typename T, int N> 
void func()
{
    T a[N];  // 使用模板參數定義局部數組；
}
           
func<double, 10>();  // 使用模板時，數值型參數必須是常量，不能是變量；

    2，數值型模板參數的限制：

       1，變量不能作為模板參數；

           1，是變量的話就不滿足准確確定的這個本質；

       2，浮點數不能作為模板參數；

           1，浮點數本身不精確；

       3，類對象不能作為模板參數；

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

    3，數值型參數本質：模板參數是在編譯階段被處理的單元，因此，在編譯階段必須准確無誤的唯一確定；

          

2，有趣的面試題：

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

       1，等差數列和的方式；

       2，見下面實例；

   

3，數值型模板參數編程實驗：

#include <iostream>
#include <string>

using namespace std;

/* 驗證上面的預備知識 */
template
< typename T, int N >  // 這里用成 double 后，編譯器顯示：error: 'double' is not a valid type for a template constant parameter
void func()
{
    T a[N] = {0};
    
    for(int i=0; i<N; i++)
    {
        a[i] = i;
    }
    
    for(int i=0; i<N; i++)
    {
        cout << a[i] << endl;
    }
}

/* 用最高效的方法驗證從 1 加到 n 的和；不用循環和等差數列求和公式 */
template
< int N >
class Sum
{
public:
    // static const int VALUE = 0;  // static 后是想定義常量，被 static 修飾后要么放入符號表、要么放到全局數據區； 這個時候 VALUE 已經確定了值，所以直接進入符號表（符號表存儲在哪里呢）；又因為 VALUE 被 static 修飾了，所以 VALUE 被放入全局數據區；
    static const int VALUE = Sum<N-1>::VALUE + N;  // 遞歸定義
};

/* 定義上述模板類的特化實現，實現遞歸出口 */
template
< >
class Sum < 1 >
{
public:
    static const int VALUE = 1;
};

int main()
{
    func<int, 10>();  // 打印 0 到 9 這十個數字；這里如果模板參數類型為 double，編譯器顯示：error: no matching function for call to 'func()'；
    
    int a = 10;
    func<int, a>();  // 在這一行編譯器顯示：
       // error: 'a' cannot appear in a constant-expression
       // error: no matching function for call to 'func()'
                     
    cout << "1 + 2 + 3 + ... + 10 = " << Sum<10>::VALUE << endl;  // 55；這里沒有加減乘除法，也沒有函數調用和循環，這里VALUE 是常量，並在編譯的時候已經確定，這里效率是最高的；
    cout << "1 + 2 + 3 + ... + 100 = " << Sum<100>::VALUE << endl;   // 5050
    
    return 0;
}    

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

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

    3，可以舉一反三，得到更多高效的程序寫法；

   

4，數組模板類編程實驗：

    1，Array.h 文件：

#ifndef _ARRAY_H_  // 防止多次包含頭文件；
#define _ARRAY_H_

template
< typename T, int N >  // 數組元素的類型和大小；
class Array
{
    T m_array[N];  // 定義一個實際的數組；
public:
    int length();
    bool set(int index, T value);
    bool get(int index, T& value);
    T& operator[] (int index);
    T operator[] (int index) const;  // 數組類對象有可能是 const 對象，這個時候就只能調用 const 函數，所以要定義這個；const 函數只能返回值，不能返回引用；
    virtual ~Array();  // 有可能被繼承
};

/* 模板類要放在一個文件中，所以實現在下面實現 */

template
< typename T, int N >
int Array<T, N>::length()
{
    return N;
}

template
< typename T, int N >
bool Array<T, N>::set(int index, T value)
{
    bool ret = (0 <= index) && (index < N);
    
    if( ret )
    {
        m_array[index] = value;
    }
    
    return ret;
}

template
< typename T, int N >
bool Array<T, N>::get(int index, T& value)
{
    bool ret = (0 <= index) && (index < N);
    
    if( ret )
    {
        value = m_array[index];
    }
    
    return ret;
}

template
< typename T, int N >
T& Array<T, N>::operator[] (int index)
{
    return m_array[index];
}

template
< typename T, int N >
T Array<T, N>::operator[] (int index) const
{
    return m_array[index];
}

template
< typename T, int N >
Array<T, N>::~Array()
{

}

#endif

    2，應用：

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

using namespace std;

int main()
{
    Array<double, 5> ad;
    
    for(int i=0; i<ad.length(); i++)
    {
        ad[i] = i * i;
    }
    
    for(int i=0; i<ad.length(); i++)
    {
        cout << ad[i] << endl;
    }
    
    return 0;
}

   

5，堆數組模板類編程實驗：

　1，HeapArray.h 文件：

#ifndef _HEAPARRAY_H_
#define _HEAPARRAY_H_

template
< typename T >
class HeapArray
{
private:
    int m_length;
    T* m_pointer;
    
    HeapArray(int len);
    HeapArray(const HeapArray<T>& obj);
    bool construct();
public:
    static HeapArray<T>* NewInstance(int length); 
    int length();
    bool get(int index, T& value);
    bool set(int index ,T value);
    T& operator [] (int index);
    T operator [] (int index) const;  // 有可能有 const 對象；
    HeapArray<T>& self();
    ~HeapArray();  // 這個時候構造函數是 private 的，也就是 HeapArray 類不希望被繼承，所以說沒有必要將它聲明為 virtual 的；
};

/* 實現要在同一個文件中 */

template
< typename T >
HeapArray<T>::HeapArray(int len)
{
    m_length = len;
}

template
< typename T >
bool HeapArray<T>::construct()
{   
    m_pointer = new T[m_length];
    
    return m_pointer != NULL;
}

template
< typename T >
HeapArray<T>* HeapArray<T>::NewInstance(int length) 
{
    HeapArray<T>* ret = new HeapArray<T>(length);
    
    if( !(ret && ret->construct()) ) 
    {
        delete ret;
        ret = 0;
    }
        
    return ret;
}

template
< typename T >
int HeapArray<T>::length()
{
    return m_length;
}

template
< typename T >
bool HeapArray<T>::get(int index, T& value)
{
    bool ret = (0 <= index) && (index < length());
    
    if( ret )
    {
        value = m_pointer[index];
    }
    
    return ret;
}

template
< typename T >
bool HeapArray<T>::set(int index, T value)
{
    bool ret = (0 <= index) && (index < length());
    
    if( ret )
    {
        m_pointer[index] = value;
    }
    
    return ret;
}

template
< typename T >
T& HeapArray<T>::operator [] (int index)
{
    return m_pointer[index];
}

template
< typename T >
T HeapArray<T>::operator [] (int index) const
{
    return m_pointer[index];
}

template
< typename T >
HeapArray<T>& HeapArray<T>::self()
{
    return *this;
}

template
< typename T >
HeapArray<T>::~HeapArray()
{
    delete[]m_pointer;
}

#endif

    2，應用：

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

using namespace std;

int main()
{   
    HeapArray<char>* pai = HeapArray<char>::NewInstance(10);
    
    if( pai != NULL )
    {
        HeapArray<char>& ai = pai->self();
        
        for(int i=0; i<ai.length(); i++)
        {
            ai[i] = i + 'a';
        }
        
        for(int i=0; i<ai.length(); i++)
        {
            cout << ai[i] << endl;
        }
    }
    
    delete pai;
    
    return 0;
}

   

6，小結：

    1，模板參數可以是數值型參數；

    2，數值型模板參數必須在編譯期間唯一確定；

    3，數組類模板是基於數值型模板參數實現的；

    4，數組類模板是簡易的線性表數據結構；