Come sovraccaricare l'operatore di indice di array per la classe wrapper di array 2D?

Question

#define ROW 3 
#define COL 4 

class Matrix 
{ 
    private: 
     int mat[ROW][COL]; 
    //..... 
    //..... 

}; 

int main() 
{ 
    Matrix m; 
    int a = m[0][1]; // reading 
    m[0][2] = m[1][1]; // writing 
} 

Penso che non sia possibile sovraccaricare direttamente [] [].

Penso di doverlo indirettamente ma come implementarlo?

Answer 1

La soluzione più semplice consiste nell'utilizzare l'operatore() in quanto consente più parametri.

class M 
{ 
    public: 
     int& operator()(int x,int y) {return at(x,y);} 
    // .. Stuff to hold data and implement at() 
}; 


M a; 
a(1,2) = 4; 

Il modo più semplice è che il primo operatore [] restituisce un oggetto intermedio che il secondo operatore [] restituisce il valore dalla matrice.

class M 
{ 
    public: 
    class R 
    { 
     private: 
      friend class M; // Only M can create these objects. 
      R(M& parent,int row): m_parent(parent),m_row(row) {} 
     public: 
       int& operator[](int col) {return m_parent.at(m_row,col);} 
     private: 
       M& m_parent; 
       int m_row; 
    }; 

    R operator[](int row) {return R(*this,row);} 

    // .. Stuff to hold data and implement at() 
}; 

M b; 
b[1][2] = 3; // This is shorthand for: 

R row = b[1]; 
int& val = row[2]; 
val  = 3; 

Answer 2

Dal momento che si desidera memorizzare i vostri elementi in array a dimensione fissa sarà abbastanza semplice:

#define ROWS 3 
#define COLS 4 

typedef int row_type[COLS]; 

class matrix { 
    row_type elements[ROWS]; 
public: 
    ... 
    row_type const& operator[](int r) const {return elements[r];} 
    row_type  & operator[](int r)  {return elements[r];} 
    ... 
}; 

che dovrebbe funzionare.

Inoltre, è possibile sostituire gli #define con costanti appropriate o utilizzare i parametri del modello per type (int) e size (3x4) per rendere la classe matrix più generica. Se si desidera supportare le dimensioni dinamiche, l'operatore [] deve restituire oggetti proxy. È possibile ma probabilmente dovresti preferire operator() con due parametri di indice per l'accesso agli elementi.