34、不一样的C++系列--数组类模板

数组类模板

首先先了解一个小知识点：
模板参数可以是数值型参数（非类型参数）,例如这样：

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 = 55func() 100 = 50501 + 2 + 3 + ... + 10 = 551 + 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;}

运行结果为：

014916abcdefghij