模板數組，下標檢查

#include <iostream>
using namespace std;

template <class T> class Array;
template <class T> class ArrayBody
...{
    friend class Array<T>;
    T* tpBody;
    int iRows, iColumn, iCurrentRow;
    ArrayBody(int iRsz, int iCsz)
    ...{
        tpBody = new T[iRsz * iRsz];
        iRows = iRsz;
        iColumn = iCsz;
        iCurrentRow = -1;
    }
public:
    T& operator[](int j)
    ...{
        bool row_error =false, column_error =false;
        try
        ...{
            if(iCurrentRow < 0 || iCurrentRow >= iRows)
                row_error =true;
            if(j < 0 || j >= iColumn)
                column_error =true;
            if(row_error || column_error)
                throw 'e';
        }
        catch (char)
        ...{
            if(row_error)
                cerr << "row access invalid!" << iCurrentRow << endl;
            if(column_error)
                cerr << "column access invalid!" << j << endl;
        }
        return tpBody[iCurrentRow * iColumn + j];
    }
    ~ArrayBody()
    ...{delete[] tpBody;}
};
template <class T> class Array
...{
    ArrayBody<T> tBody;
public:
    ArrayBody<T>& operator[](int i)
    ...{
        tBody.iCurrentRow = i;
        return tBody;
    }
    Array(int iRsz, int iCsz): tBody(iRsz, iCsz)...{}
};

 

#include "t1.h"

void main()
...{
    Array<int> a1(10,20);
    Array<double> a2(3,5);
    int b1;
    double b2;
    b1 = a1[-5][10];
    b1 = a1[10][15];
    b1 = a1[1][4];
    b2 = a2[2][6];
    b2 = a2[10][20];
    b2 = a2[1][4];
    getchar();
}

此題要求當訪問二位數組元素時，通過定義類，判斷行下標及列下標越界與否。如果不看程序，可能會認爲由於是二維數組，那麼要用到兩次運算符[ ]重載。但是如何在一個類中實現兩次同一個運算符的重載呢？這樣做似乎不太方便，那麼應該想到定義兩個類，當第一個類調用重載的操作符時，使此函數返回第二個類的對象，在第二個類中，同樣定義了運算符[ ]重載。但在第一個類中的重載操作符要能訪問第二個類的私有成員，那麼就應該把第一個類聲明爲第二個類的友元。