C++中的数据类模板

1，预备知识：

1，模板参数可以是数值型参数（非类型参数）：

1，代码示例：

 template <typename T, int N>
 void func()
 {
     T a[N];  // 使用模板参数定义局部数组；
 }

 func<double, >();  // 使用模板时，数值型参数必须是常量，不能是变量；

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] = {};

     for(int i=; i<N; i++)
     {
         a[i] = i;
     }

     for(int i=; 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->::VALUE + N;  // 递归定义
 };

 /* 定义上述模板类的特化实现，实现递归出口 */
 template
 < >
 class Sum <  >
 {
 public:
     static const int VALUE = ;
 };

 int main()
 {
     func<int, >();  // 打印 0 到 9 这十个数字；这里如果模板参数类型为 double，编译器显示：error: no matching function for call to 'func()'；

     int a = ;
     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<>::VALUE << endl;  // 55；这里没有加减乘除法，也没有函数调用和循环，这里VALUE 是常量，并在编译的时候已经确定，这里效率是最高的；
     cout << "1 + 2 + 3 + ... + 100 = " << Sum<>::VALUE << endl;   //

     return ;
 }    

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 = ( <= 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 = ( <= 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, > ad;

     for(int i=; i<ad.length(); i++)
     {
         ad[i] = i * i;
     }

     for(int i=; i<ad.length(); i++)
     {
         cout << ad[i] << endl;
     }

     return ;
 }

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 = ;
     }

     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 = ( <= index) && (index < length());

     if( ret )
     {
         value = m_pointer[index];
     }

     return ret;
 }

 template
 < typename T >
 bool HeapArray<T>::set(int index, T value)
 {
     bool ret = ( <= 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();

     if( pai != NULL )
     {
         HeapArray<char>& ai = pai->self();

         for(int i=; i<ai.length(); i++)
         {
             ai[i] = i + 'a';
         }

         for(int i=; i<ai.length(); i++)
         {
             cout << ai[i] << endl;
         }
     }

     delete pai;

     return ;
 }

6，小结：

1，模板参数可以是数值型参数；

2，数值型模板参数必须在编译期间唯一确定；

3，数组类模板是基于数值型模板参数实现的；

4，数组类模板是简易的线性表数据结构；