第60课数组类模板

预备知识：

有趣的面试题：

示例：

当编译器编译到第26行时，看到const就会将VALUE放入符号表，又看到了static，因此这个变量也进入了全局数据区。静态的const变量是可以在类中直接赋值的。

最快的求和程序如下：

运行结果如下：

完善程序：

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 template
 7 < typename T, int N >
 8 void func()
 9 {
10     T a[N] = {0};
11     
12     for(int i=0; i<N; i++)
13     {
14         a[i] = i;
15     }
16     
17     for(int i=0; i<N; i++)
18     {
19         cout << a[i] << endl;
20     }
21 }
22 
23 template
24 < int N >
25 class Sum
26 {
27 public:
28     static const int VALUE = Sum<N-1>::VALUE + N;
29 };
30 
31 template
32 < >
33 class Sum < 1 >
34 {
35 public:
36     static const int VALUE = 1;
37 };
38 
39 
40 int main()
41 {
42     cout << "1 + 2 + 3 + ... + 10 = " << Sum<10>::VALUE << endl;
43     cout << "1 + 2 + 3 + ... + 100 = " << Sum<100>::VALUE << endl;
44     
45     return 0;
46 }

第33行就是特化。这是一个递归的过程。

运行结果如下：

这里的VALUE值在编译的时候就确定了，因此非常高效。

数组类模板实现：

Array.h

 1 #ifndef _ARRAY_H_
 2 #define _ARRAY_H_
 3 
 4 template
 5 < typename T, int N >
 6 class Array
 7 {
 8     T m_array[N];
 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;
15     virtual ~Array();
16 };
17 
18 template
19 < typename T, int N >
20 int Array<T, N>::length()
21 {
22     return N;
23 }
24 
25 template
26 < typename T, int N >
27 bool Array<T, N>::set(int index, T value)
28 {
29     bool ret = (0 <= index) && (index < N);
30     
31     if( ret )
32     {
33         m_array[index] = value;
34     }
35     
36     return ret;
37 }
38 
39 template
40 < typename T, int N >
41 bool Array<T, N>::get(int index, T& value)
42 {
43     bool ret = (0 <= index) && (index < N);
44     
45     if( ret )
46     {
47         value = m_array[index];
48     }
49     
50     return ret;
51 }
52 
53 template
54 < typename T, int N >
55 T& Array<T, N>::operator[] (int index)
56 {
57     return m_array[index];
58 }
59 
60 template
61 < typename T, int N >
62 T Array<T, N>::operator[] (int index) const
63 {
64     return m_array[index];
65 }
66 
67 template
68 < typename T, int N >
69 Array<T, N>::~Array()
70 {
71 
72 }
73 
74 #endif

主函数：

改进数组类模板并使用二阶构造：

  1 #ifndef _HEAPARRAY_H_
  2 #define _HEAPARRAY_H_
  3 
  4 template
  5 < typename T >
  6 class HeapArray
  7 {
  8 private:
  9     int m_length;
 10     T* m_pointer;
 11     
 12     HeapArray(int len);
 13     HeapArray(const HeapArray<T>& obj);
 14     bool construct();
 15 public:
 16     static HeapArray<T>* NewInstance(int length); 
 17     int length();
 18     bool get(int index, T& value);
 19     bool set(int index ,T value);
 20     T& operator [] (int index);
 21     T operator [] (int index) const;
 22     HeapArray<T>& self();
 23     ~HeapArray();
 24 };
 25 
 26 template
 27 < typename T >
 28 HeapArray<T>::HeapArray(int len)
 29 {
 30     m_length = len;
 31 }
 32 
 33 template
 34 < typename T >
 35 bool HeapArray<T>::construct()
 36 {   
 37     m_pointer = new T[m_length];
 38     
 39     return m_pointer != NULL;
 40 }
 41 
 42 template
 43 < typename T >
 44 HeapArray<T>* HeapArray<T>::NewInstance(int length) 
 45 {
 46     HeapArray<T>* ret = new HeapArray<T>(length);
 47     
 48     if( !(ret && ret->construct()) ) 
 49     {
 50         delete ret;
 51         ret = 0;
 52     }
 53         
 54     return ret;
 55 }
 56 
 57 template
 58 < typename T >
 59 int HeapArray<T>::length()
 60 {
 61     return m_length;
 62 }
 63 
 64 template
 65 < typename T >
 66 bool HeapArray<T>::get(int index, T& value)
 67 {
 68     bool ret = (0 <= index) && (index < length());
 69     
 70     if( ret )
 71     {
 72         value = m_pointer[index];
 73     }
 74     
 75     return ret;
 76 }
 77 
 78 template
 79 < typename T >
 80 bool HeapArray<T>::set(int index, T value)
 81 {
 82     bool ret = (0 <= index) && (index < length());
 83     
 84     if( ret )
 85     {
 86         m_pointer[index] = value;
 87     }
 88     
 89     return ret;
 90 }
 91 
 92 template
 93 < typename T >
 94 T& HeapArray<T>::operator [] (int index)
 95 {
 96     return m_pointer[index];
 97 }
 98 
 99 template
100 < typename T >
101 T HeapArray<T>::operator [] (int index) const
102 {
103     return m_pointer[index];
104 }
105 
106 template
107 < typename T >
108 HeapArray<T>& HeapArray<T>::self()
109 {
110     return *this;
111 }
112 
113 template
114 < typename T >
115 HeapArray<T>::~HeapArray()
116 {
117     delete[]m_pointer;
118 }
119 
120 
121 #endif

主函数如下：

 1 #include <iostream>
 2 #include <string>
 3 #include "Array.h"
 4 #include "HeapArray.h"
 5 
 6 using namespace std;
 7 
 8 int main()
 9 {
10     Array<double, 5> ad;
11     
12     for(int i=0; i<ad.length(); i++)
13     {
14         ad[i] = i * i;
15     }
16     
17     for(int i=0; i<ad.length(); i++)
18     {
19         cout << ad[i] << endl;
20     }
21     
22     cout << endl;
23     
24     HeapArray<char>* pai = HeapArray<char>::NewInstance(10);
25     
26     if( pai != NULL )
27     {
28         HeapArray<char>& ai = pai->self();
29         
30         for(int i=0; i<ai.length(); i++)
31         {
32             ai[i] = i + 'a';
33         }
34         
35         for(int i=0; i<ai.length(); i++)
36         {
37             cout << ai[i] << endl;
38         }
39     }
40     
41     delete pai;
42     
43     return 0;
44 }

运行结果如下：

小结：

第60课 数组类模板

第60课数组类模板