首先先了解一个小知识点：
模板参数可以是数值型参数（非类型参数）,例如这样：
template
<typename T, int N>
void func()
{
//使用模板参数定义局部数组
T a[N];
}
//使用
func<double, 10>();
这种数值型模板参数也有很多限制：
- 变量不能作为模板参数
- 浮点数不能作为模板参数
- 类对象不能作为模板参数
- ........
本质：模板参数是在编译阶段被处理的单元，因此，在编译阶段必须准确无误的唯一确定。
了解完数值型模板参数这个知识点以后，再来做一个面试题：
用一个最高效的方法求1+2+3+4+....+N的值！
或许大家会想到使用一个循环累加、递归、或者直接使用公式一步就可以得到结果。但这里介绍一个最高效的办法，和上面的小知识点有关：
#include <iostream>
#include <string>
using namespace std;
//定义一个函数模板
template
< typename T, int N >
void func()
{
T a[N] = {0};
int sum = 0;
int i = 0;
for(i=0; i<N; i++)
{
a[i] = i;
}
for(i=0; i<N; i++)
{
sum += a[i];
}
sum += i;
cout << "func() " << N << " = "<< sum << endl;
}
//定义函数模板
template
< int N >
class Sum
{
public:
//递归
static const int VALUE = Sum<N-1>::VALUE + N;
};
//定义函数模板，参数直接固定，且为数值
template
< >
class Sum < 1 >
{
public:
static const int VALUE = 1;
};
int main()
{
func<int, 10>();
func<int, 100>();
cout << "1 + 2 + 3 + ... + 10 = " << Sum<10>::VALUE << endl;
cout << "1 + 2 + 3 + ... + 100 = " << Sum<100>::VALUE << endl;
return 0;
}
输出结果为：
func() 10 = 55
func() 100 = 5050
1 + 2 + 3 + ... + 10 = 55
1 + 2 + 3 + ... + 100 = 5050
是不是会有疑问，代码中表述了2中方式的求值过程。第一种是正常的方法，直接for循环来累加求值；第二种是使用函数模板递归来求值。可是这两种方式没有什么不同呀！
其实这里是有区别的，我们都知道对于函数模板编译器是分两次编译。那在这里对于func函数模板，第一次编译是编译函数模板本身，第二次是替换参数后的代码，也就是说最终的值是在运行期main函数中调用这个函数，传入参数，然后求值；那对于sum函数模板，就不一样了，第一次是编译函数模板本身，但是这里是使用递归，那就是说第一次编译的时候就已经把值求出来，第二次编译是有一个静态变量存在函数体中。
对于两种方法，第一个是在运行期求值，会消耗掉计算量，第二个是在编译器就求出来了，运行期直接输出，不消耗任何计算量。所以第二个方法更高效。
最后在这里用代码阐述array类的内部实现过程，分两种实现，一种是在栈上开辟空间，一种是在堆上开辟空间：
在栈上开辟空间演示（Array.h）
#ifndef _ARRAY_H_
#define _ARRAY_H_
template
< typename T, int N >
class Array
{
//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;
//析构函数
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
在堆上开辟空间演示（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;
//获取当前类对象指针
HeapArray<T>& self();
~HeapArray();
};
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
调用函数（main.cpp）：
#include <iostream>
#include <string>
#include "Array.h"
#include "HeapArray.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;
}
cout << endl;
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;
}
运行结果为：
0
1
4
9
16
a
b
c
d
e
f
g
h
i
j
