由一维数组表示的N维数组实现(C++)

工作中，经常需要表示多维数组（如二维矩阵），常见的做法是使用T **pArr；

T **pArr = new T*[M];//创建二维数组[M][N]
for (int i=;i<M;i++)
{
    pArr[i] = new T[N];
}

销毁内存：

for (int i=;i<M;i++)
{
    delete[] pArr[i];
}
delete[] pArr;

若是三维数组，需要创建三次，T*** pArr；以此类推，操作繁琐。

为方便动态生成多维数组，本文使用一维数据表示多维数组，并基于C++模板和运算符重载，使用一维数组动态表示多维数组，支持数据切片，简化多维数组的处理和使用。

#ifndef MYNDARRAY_H_20170226
#define MYNDARRAY_H_20170226

#include <assert.h>
#include <iostream>
using namespace std;

//on dim array represent n-dim array
typedef unsigned int iNum;//使用unsigned int作为后续整数型数据类型

typedef struct stMyRange{//闭区间[start,end]
    iNum Start;//start 和end 从 0开始
    iNum End;//
    stMyRange(){
        Start = End = ;
    }
    stMyRange(iNum start,iNum end){
        assert(start >=  && end >= start);
        Start = start;
        End = end;
    }
}stMyRange;

typedef struct stMyRank{//rank代表一个数据维度
    iNum Rank;//数据维度的长度
    iNum Start;//数据维度开始位置，start from 0
    iNum End;//数据维度结束位置，start from 0
    stMyRank(){
        Rank = ;//if dim == 0, this rank is not exist
        Start = ;//if start ==0 && end == Rank-1, reprsent the whole rank;
        End = ;
    }
    void SetRank(iNum rank){
        assert(rank > );
        Rank = rank;
        Start = ;
        End = Rank - ;
    }
    void SetRange(stMyRange rang){
        assert(rang.Start >=  && rang.End >= rang.Start && rang.End < Rank);
        Start = rang.Start;
        End = rang.End;
    }
}stMyRank;

//目前设置最大数据维度为4，后续根据需要可扩展
#define MyMaxRank 4

template<class T>
class MyNDArray{//C++模板使用，可表示多种类型的数据
protected:
    T* m_pData;//row based storage，行优先存储
    stMyRank m_Rank[MyMaxRank];//记录数据维度
    iNum m_iRankCap;//total rank capacity;数据维度个数
    bool m_isSlice;//if slice==true, it will reuse the m_pData of its parent;//是否是数据切片
public:
    MyNDArray(){
        m_pData = NULL;
        m_iRankCap = ;
        m_isSlice = false;
    }
    MyNDArray(iNum rank1){
        m_Rank[].SetRank(rank1);
        m_iRankCap = ;
        m_isSlice = false;
        Init();
    }
    MyNDArray(iNum rank1,iNum rank2){
        m_Rank[].SetRank(rank1);
        m_Rank[].SetRank(rank2);
        m_iRankCap = ;
        m_isSlice = false;
        Init();
    }
    MyNDArray(iNum rank1,iNum rank2,iNum rank3){
        m_Rank[].SetRank(rank1);
        m_Rank[].SetRank(rank2);
        m_Rank[].SetRank(rank3);
        m_iRankCap = ;
        m_isSlice = false;
        Init();
    }
    MyNDArray(iNum rank1,iNum rank2,iNum rank3,iNum rank4){
        m_Rank[].SetRank(rank1);
        m_Rank[].SetRank(rank2);
        m_Rank[].SetRank(rank3);
        m_Rank[].SetRank(rank4);
        m_iRankCap = ;
        m_isSlice = false;
        Init();
    }
    //创建数据切片，新的ndarray共享partent的pData数据域
    MyNDArray(MyNDArray& parent,stMyRank rank1){
        m_Rank[]=rank1;
        m_iRankCap = ;
        m_isSlice = true;
        m_pData = parent.GetData();
    }
    MyNDArray(MyNDArray& parent,stMyRank rank1,stMyRank rank2){
        m_Rank[]=rank1;
        m_Rank[]=rank2;
        m_iRankCap = ;
        m_isSlice = true;
        m_pData = parent.GetData();
    }
    MyNDArray(MyNDArray& parent,stMyRank rank1,stMyRank rank2,stMyRank rank3){
        m_Rank[]=rank1;
        m_Rank[]=rank2;
        m_Rank[]=rank3;
        m_iRankCap = ;
        m_isSlice = true;
        m_pData = parent.GetData();
    }
    MyNDArray(MyNDArray& parent,stMyRank rank1,stMyRank rank2,stMyRank rank3,stMyRank rank4){
        m_Rank[]=rank1;
        m_Rank[]=rank2;
        m_Rank[]=rank3;
        m_Rank[]=rank4;
        m_iRankCap = ;
        m_isSlice = true;
        m_pData = parent.GetData();
    }
    ~MyNDArray(){
        Clear();
    }
    void Clear(){
        if(!m_isSlice && m_pData != NULL){
            delete[] m_pData;
            m_pData = NULL;
        }
    }

    T* GetData(){
        return m_pData;
    }
    void SetData(T* pData){
        m_pData = pData;
    }
    iNum RankCap(){
        return m_iRankCap;
    }
    iNum RankSize(iNum rank){//start from 1，获取第i维的维度长度
        if(rank < ) return ;
        return m_Rank[rank-].End - m_Rank[rank-].Start + ;
    }

    MyNDArray Slice(stMyRange rang1){//range start from 0，数据切片
        stMyRank rank1 = m_Rank[];
        rank1.SetRange(rang1);
        MyNDArray res(*this,rank1);
        return res;
    }
    MyNDArray Slice(stMyRange rang1,stMyRange rang2){
        stMyRank rank1 = m_Rank[];
        rank1.SetRange(rang1);
        stMyRank rank2 = m_Rank[];
        rank2.SetRange(rang2);
        MyNDArray res(*this,rank1,rank2);
        return res;
    }
    MyNDArray Slice(stMyRange rang1,stMyRange rang2,stMyRange rang3){
        stMyRank rank1 = m_Rank[];
        rank1.SetRange(rang1);
        stMyRank rank2 = m_Rank[];
        rank2.SetRange(rang2);
        stMyRank rank3 = m_Rank[];
        rank3.SetRange(rang3);
        MyNDArray res(*this,rank1,rank2,rank3);
        return res;
    }
    MyNDArray Slice(stMyRange rang1,stMyRange rang2,stMyRange rang3,stMyRange rang4){
        stMyRank rank1 = m_Rank[];
        rank1.SetRange(rang1);
        stMyRank rank2 = m_Rank[];
        rank2.SetRange(rang2);
        stMyRank rank3 = m_Rank[];
        rank3.SetRange(rang3);
        stMyRank rank4 = m_Rank[];
        rank4.SetRange(rang4);
        MyNDArray res(*this,rank1,rank2,rank3,rank4);
        return res;
    }

    //override operator()， 使用MyNDarray arr; arr(1,2,3,4)
    T& operator()(iNum r1=,iNum r2=,iNum r3=,iNum r4=){
        assert(m_pData != NULL);
        return m_pData[StoreIndex(r1,r2,r3,r4)];
    }
    const T& operator()(iNum r1=,iNum r2=,iNum r3=,iNum r4=) const{
        assert(m_pData != NULL);
        return m_pData[StoreIndex(r1,r2,r3,r4)];
    }
protected:
    iNum StoreIndex(iNum r1,iNum r2,iNum r3,iNum r4){//数据存储引擎，以行优先存储
        assert(m_iRankCap > );
        if(m_isSlice){
            r1 += m_Rank[].Start;
            r2 += m_Rank[].Start;
            r3 += m_Rank[].Start;
            r4 += m_Rank[].Start;
        }
　　　　//判断数据是否在合法的范围内
        if(m_iRankCap >= ) assert(r1 >= m_Rank[].Start && r1 <= m_Rank[].End);
        if(m_iRankCap >= ) assert(r2 >= m_Rank[].Start && r2 <= m_Rank[].End);
        if(m_iRankCap >= ) assert(r3 >= m_Rank[].Start && r3 <= m_Rank[].End);
        if(m_iRankCap >= ) assert(r4 >= m_Rank[].Start && r4 <= m_Rank[].End);
        iNum index = ;
        index = r1 + m_Rank[].Rank * (
            r2 + m_Rank[].Rank * (
            r3 + m_Rank[].Rank * r4
            ));//row based storage

        return index;
    }

    void Init(){//初始化内存
        iNum size = ;
        for (int i=;i<m_iRankCap;i++)
        {
            size *= m_Rank[i].Rank;
        }
        if(m_iRankCap >  && size > )
        {
            m_pData = new T[size];
        }
        else
            m_pData = NULL;
    }
};

//重载输入>>和输出<<，用于数据读取和写入
//override operator >>
template<class T>
istream& operator >> (istream& myin,MyNDArray<T>& arr){
    iNum r1,r2,r3,r4;
    r1 = arr.RankSize();
    r2 = arr.RankSize();
    r3 = arr.RankSize();
    r4 = arr.RankSize();
    iNum rankCap = arr.RankCap();
    if(rankCap < ) r2 = ;
    if(rankCap < ) r3 = ;
    if(rankCap < ) r4 = ;

    for (int i4=;i4<r4;i4++)
    {
        for (int i3=;i3<r3;i3++)
        {
            for (int i2=;i2<r2;i2++)
            {
                for (int i1=;i1<r1;i1++)
                {
                    myin >> arr(i1,i2,i3,i4);//调用重载的operator()，读取数据
                }
            }
        }
    }
    return myin;
}

//override operator <<
template<class T>
ostream& operator << (ostream& myout,MyNDArray<T>& arr){
    iNum r1,r2,r3,r4;
    r1 = arr.RankSize();
    r2 = arr.RankSize();
    r3 = arr.RankSize();
    r4 = arr.RankSize();
    iNum rankCap = arr.RankCap();
    if(rankCap < ) r2 = ;
    if(rankCap < ) r3 = ;
    if(rankCap < ) r4 = ;

    for (int i4=;i4<r4;i4++)
    {
        myout<<"rank4:"<<i4+<<endl;
        for (int i3=;i3<r3;i3++)
        {
            myout<<"rank3:"<<i3+<<endl;
            for (int i2=;i2<r2;i2++)
            {
                for (int i1=;i1<r1;i1++)
                {
                    myout <<arr(i1,i2,i3,i4)<<"\t";
                }
                myout<<"\n";
            }
        }
        myout<<"\n";
    }
    return myout;
}
#endif

使用方法：

int main(int argc, char* argv[])
{
    MyNDArray<int> ndarr(,,,);
    ifstream fin("ndarr.txt",ios::in);
    fin>>ndarr;
    cout<<ndarr;
    stMyRange range1(,);
    stMyRange range2(,);
    stMyRange range3(,);
    stMyRange range4(,);
    MyNDArray<int> slice = ndarr.Slice(range1,range2,range3,range4);
    cout<<"slice:"<<endl<<slice<<endl;
    cin>>ndarr;
    return ;
}

ndarr.txt内如如下：

上述测试程序的输出结果为：

35 36

38 39

满足数据切片要求。

参考资料：

C++运算符重载：http://www.cnblogs.com/lfsblack/archive/2012/10/01/2709476.html

python.ndarray简单使用

C++ prime中的模板章节