模板实现任意维数组

 

在OOT课程中老师给出了模板实现的2维数组，我受到启发写了一个实现任意维数组的模板。它与C++中默认的模板很像，并且能够检查越界。

// MyArray.cpp
// by jefferyzb @ 07.01.14
// OOT 2001_No.3


#include  < iostream.h >
#include  < stdarg.h >

// original 2-demission array template

template  < class  T >   class  Array;

template  < class  T >   class  ArrayTmp  ... { // 第二层类型
    friend class Array<T>;
    T* tpBody;
    int iRows, iColumns, iCurrentRow;
    
    ArrayTmp(int iRsz, int iCsz)
    ...{ 
        tpBody = new T[iRsz*iCsz]; 
        iRows = iRsz; 
        iColumns = iCsz;
        iCurrentRow = -1; 
    }
    
public:
    T& operator[ ](int j) 
    ...{ 
        return tpBody[iCurrentRow + j * iRows]; 
    }
} ;

template  < class  T >   class  Array  ... { // 第一层类型
    ArrayTmp<T> tTmp; // 第一层类型与第二层类型的关联
    
public:
    Array(int iRsz, int iCsz) : tTmp(iRsz, iCsz) ...{}
    
    ArrayTmp<T>& operator[ ](int i)
    ...{ 
        tTmp.iCurrentRow = i; 
        return tTmp; 
    }
} ;
/**/ ///
// modified n-demission array template

int  cnt  =   1 ;

class  Integer
... {
    
public:
    int n;

    Integer(int i=cnt) 
    ...{
        n = i;
        cnt++;
    }

    inline friend ostream & operator << (ostream& o, const Integer& output)
    ...{
        o <<"Integer:"<<output.n;
        return o;
    }
} ;

template  < class  T >   class  ArrayBase 
... { 
    T* tpBody;
    int demision,curDemision;
    int * ipL;
    int length;
    int index;

public:

    ArrayBase(int demision, ...)
    ...{ 
        this->demision = demision;
        this->curDemision = 0;
        this->ipL = new int[demision];
        this->length = 1;
        this->index = 0;
        
        int iL;
        va_list ap;
        va_start ( ap, demision );
        for ( int i= 0; i< demision; i++ )
        ...{
            iL = va_arg (ap, int);
            this->ipL[i] = iL;
            length *= iL;
        }
        va_end (ap);

        this->tpBody = new T[length];
    }
    
    
    ArrayBase& operator[ ](int j) 
    ...{ 
        //refresh when reach the last brackets
        if(++curDemision > demision)
        ...{
            this->curDemision = 1;
            this->index = 0;
        }

        int size = 1;
        
        for (int i=demision-1; i>curDemision-1; i-- )
        ...{
            size *= this->ipL[i];
        }

        this->index += j * size;
    
        //check
        if(this->index >= this->length)
        ...{
            cout<<"Array out of bound ";
            this->index = 0;
        }

        return *this; 
    }
    
    ArrayBase & operator=(T t)
    ...{
        *(tpBody+index) = t;
        return *this;
    }
    
    friend ostream & operator << (ostream& o, const ArrayBase& output)
    ...{
        T * t = output.tpBody;
        t += output.index;
        o<<*t;
        return o;
    }
} ;



void  main()
... {
    ArrayBase<int> a(4,2,3,4,5);
    a[1][2][3][4] = 9;
    cout<<a[1][2][3][4]<<endl;

    ArrayBase<Integer> b(4,2,3,4,5);
    b[1][2][3][4] = Integer(11);
    cout<<b[1][2][3][4]<<endl;
}