标签：ram 不用 元素 编译器 运行 def opera 数组元素 length
1，预备知识：
1，模板参数可以是数值型参数（非类型参数）：
1，代码示例：
1 template <typename T, int N> 2 void func() 3 { 4 T a[N]; // 使用模板参数定义局部数组； 5 } 6 7 func<double, 10>(); // 使用模板时，数值型参数必须是常量，不能是变量；
2，数值型模板参数的限制：
1，变量不能作为模板参数；
1，是变量的话就不满足准确确定的这个本质；
2，浮点数不能作为模板参数；
1，浮点数本身不精确；
3，类对象不能作为模板参数；
1，类对象编译时不能唯一确定的，同变量一样；
3，数值型参数本质：模板参数是在编译阶段被处理的单元，因此，在编译阶段必须准确无误的唯一确定；
2，有趣的面试题：
1，用你觉得最高效的方法求 1 + 2 + 3 + ... + N 的值；
1，等差数列和的方式；
2，见下面实例；
3，数值型模板参数编程实验：
1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 /* 验证上面的预备知识 */ 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<N; i++) 14 { 15 a[i] = i; 16 } 17 18 for(int i=0; i<N; i++) 19 { 20 cout << a[i] << endl; 21 } 22 } 23 24 /* 用最高效的方法验证从 1 加到 n 的和；不用循环和等差数列求和公式 */ 25 template 26 < int N > 27 class Sum 28 { 29 public: 30 // static const int VALUE = 0; // static 后是想定义常量，被 static 修饰后要么放入符号表、要么放到全局数据区； 这个时候 VALUE 已经确定了值，所以直接进入符号表（符号表存储在哪里呢）；又因为 VALUE 被 static 修饰了，所以 VALUE 被放入全局数据区； 31 static const int VALUE = Sum<N-1>::VALUE + N; // 递归定义 32 }; 33 34 /* 定义上述模板类的特化实现，实现递归出口 */ 35 template 36 < > 37 class Sum < 1 > 38 { 39 public: 40 static const int VALUE = 1; 41 }; 42 43 int main() 44 { 45 func<int, 10>(); // 打印 0 到 9 这十个数字；这里如果模板参数类型为 double，编译器显示：error: no matching function for call to ‘func()‘； 46 47 int a = 10; 48 func<int, a>(); // 在这一行编译器显示： 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；这里没有加减乘除法，也没有函数调用和循环，这里VALUE 是常量，并在编译的时候已经确定，这里效率是最高的； 53 cout << "1 + 2 + 3 + ... + 100 = " << Sum<100>::VALUE << endl; // 5050 54 55 return 0; 56 }
1，这里的相加求和是在编译器编译程序的时候完成的，编译完程序后，要求的和的值已经确定，在运行的时候，就直接可以访问这个值，不需要做任何的运算和循环，因此效率最高；
2，这个最高效的求和依赖了模板技术、模板特化技术、数值型模板参数技术；
3，可以举一反三，得到更多高效的程序写法；
4，数组模板类编程实验：
1，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; // 数组类对象有可能是 const 对象，这个时候就只能调用 const 函数，所以要定义这个；const 函数只能返回值，不能返回引用； 15 virtual ~Array(); // 有可能被继承 16 }; 17 18 /* 模板类要放在一个文件中，所以实现在下面实现 */ 19 20 template 21 < typename T, int N > 22 int Array<T, N>::length() 23 { 24 return N; 25 } 26 27 template 28 < typename T, int N > 29 bool Array<T, N>::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<T, N>::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 52 return ret; 53 } 54 55 template 56 < typename T, int N > 57 T& Array<T, N>::operator[] (int index) 58 { 59 return m_array[index]; 60 } 61 62 template 63 < typename T, int N > 64 T Array<T, N>::operator[] (int index) const 65 { 66 return m_array[index]; 67 } 68 69 template 70 < typename T, int N > 71 Array<T, N>::~Array() 72 { 73 74 } 75 76 #endif
2，应用：
1 #include <iostream> 2 #include <string> 3 #include "Array.h" 4 5 using namespace std; 6 7 int main() 8 { 9 Array<double, 5> ad; 10 11 for(int i=0; i<ad.length(); i++) 12 { 13 ad[i] = i * i; 14 } 15 16 for(int i=0; i<ad.length(); i++) 17 { 18 cout << ad[i] << endl; 19 } 20 21 return 0; 22 }
5，堆数组模板类编程实验：
1，HeapArray.h 文件：
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; // 有可能有 const 对象； 22 HeapArray<T>& self(); 23 ~HeapArray(); // 这个时候构造函数是 private 的，也就是 HeapArray 类不希望被继承，所以说没有必要将它声明为 virtual 的； 24 }; 25 26 /* 实现要在同一个文件中 */ 27 28 template 29 < typename T > 30 HeapArray<T>::HeapArray(int len) 31 { 32 m_length = len; 33 } 34 35 template 36 < typename T > 37 bool HeapArray<T>::construct() 38 { 39 m_pointer = new T[m_length]; 40 41 return m_pointer != NULL; 42 } 43 44 template 45 < typename T > 46 HeapArray<T>* HeapArray<T>::NewInstance(int length) 47 { 48 HeapArray<T>* ret = new HeapArray<T>(length); 49 50 if( !(ret && ret->construct()) ) 51 { 52 delete ret; 53 ret = 0; 54 } 55 56 return ret; 57 } 58 59 template 60 < typename T > 61 int HeapArray<T>::length() 62 { 63 return m_length; 64 } 65 66 template 67 < typename T > 68 bool HeapArray<T>::get(int index, T& value) 69 { 70 bool ret = (0 <= index) && (index < length()); 71 72 if( ret ) 73 { 74 value = m_pointer[index]; 75 } 76 77 return ret; 78 } 79 80 template 81 < typename T > 82 bool HeapArray<T>::set(int index, T value) 83 { 84 bool ret = (0 <= index) && (index < length()); 85 86 if( ret ) 87 { 88 m_pointer[index] = value; 89 } 90 91 return ret; 92 } 93 94 template 95 < typename T > 96 T& HeapArray<T>::operator [] (int index) 97 { 98 return m_pointer[index]; 99 } 100 101 template 102 < typename T > 103 T HeapArray<T>::operator [] (int index) const 104 { 105 return m_pointer[index]; 106 } 107 108 template 109 < typename T > 110 HeapArray<T>& HeapArray<T>::self() 111 { 112 return *this; 113 } 114 115 template 116 < typename T > 117 HeapArray<T>::~HeapArray() 118 { 119 delete[]m_pointer; 120 } 121 122 #endif
2，应用：
1 #include <iostream> 2 #include <string> 3 #include "HeapArray.h" 4 5 using namespace std; 6 7 int main() 8 { 9 HeapArray<char>* pai = HeapArray<char>::NewInstance(10); 10 11 if( pai != NULL ) 12 { 13 HeapArray<char>& ai = pai->self(); 14 15 for(int i=0; i<ai.length(); i++) 16 { 17 ai[i] = i + ‘a‘; 18 } 19 20 for(int i=0; i<ai.length(); i++) 21 { 22 cout << ai[i] << endl; 23 } 24 } 25 26 delete pai; 27 28 return 0; 29 }
6，小结：
1，模板参数可以是数值型参数；
2，数值型模板参数必须在编译期间唯一确定；
3，数组类模板是基于数值型模板参数实现的；
4，数组类模板是简易的线性表数据结构；
标签：ram 不用 元素 编译器 运行 def opera 数组元素 length
原文地址：https://www.cnblogs.com/dishengAndziyu/p/10919050.html
