Newsgroup: it.comp.lang.c++
Titolo: Dimensioni multiple con []

Salve a tutti,
qualcuno potrebbe spiegarmi o meglio mandarmi un esempio, di come utilizzare
l'overloading dell'operatore [] per avere un oggetto con due dimensioni tipo
matrice.
Grazie a tutti
        Ciao Pevar...

 matrice.
Il suggerimento delle FAQ di comp.lang.c++ e' quello di usare
operator() :
[13.8] How do I create a subscript operator for a Matrix class?
Use operator() rather than operator[].
When you have multiple subscripts, the cleanest way to do it is with operator()
rather than with operator[].  The reason is that operator[] always takes
exactly one parameter, but operator() can take any number of parameters (in the
case of a rectangular matrix, two paramters are needed).
For example:
    class Matrix {
    public:
      Matrix(unsigned rows, unsigned cols);
      double& operator() (unsigned row, unsigned col);
      double  operator() (unsigned row, unsigned col) const;
      // ...
     ~Matrix();                              // Destructor
      Matrix(const Matrix& m);               // Copy constructor
      Matrix& operator= (const Matrix& m);   // Assignment operator
      // ...
    private:
      unsigned rows_, cols_;
      double* data_;
    };
    inline
    Matrix::Matrix(unsigned rows, unsigned cols)
      : rows_ (rows),
        cols_ (cols),
        data_ (new double[rows * cols])
    {
      if (rows == 0 || cols == 0)
        throw BadIndex("Matrix constructor has 0 size");
    }
    inline
    Matrix::~Matrix()
    {
      delete[] data_;
    }
    inline
    double& Matrix::operator() (unsigned row, unsigned col)
    {
      if (row >= rows_ || col >= cols_)
        throw BadIndex("Matrix subscript out of bounds");
      return data_[cols_*row + col];
    }
    inline
    double Matrix::operator() (unsigned row, unsigned col) const
    {
      if (row >= rows_ || col >= cols_)
        throw BadIndex("const Matrix subscript out of bounds");
      return data_[cols_*row + col];
    }
-- 
Maurizio Loreti                      
http://wwwcdf.pd.infn.it/~loreti/mlo.html
Un. of Padova, Dept. of Physics - Padova, Italy          
lor...@padova.infn.it


Il trucco consiste nel ritornare un riferimento alla classe cui appartiene
l'operatore, in modo che a[b][c] sia tradotta in
a.operator[](b).operator[](c)
Sta attento, ridefinire operator[] non e` affatto banale e se non hai studiato
bene il problema i risultati potrebbero
essere diversi da quelli che ti aspetteresti.
class 
----------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
----------------------------------------------------------

 a.operator[](b).operator[](c)
Oppure si può più semplicemente utilizzare a.operator(b, c) e quindi
scrivere a(b, c).
EMG




 Aggiungerei che se ritorni &T  (usando il template) č meglio.
No, non va bene, se ritorni direttamente un riferimento a T non puoi
utilizzare il template con indici multipli. Bisogna necessariamente
ritornare un riferimento alla classe template. Quello che avevo lasciato
implicito nella risposta e` che la classe template deve fornire
un meccanismo per passare al valore di tipo T.
Ovviamente quando dicevo che l'operazione non e` banale, mi riferivo al
problema di controllare operazioni non lecite.
Saluti,
Paolo
-- 
------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
 
http://www.cli.di.unipi.it/~marotta
  G: Potreste commentare l'attuale
     panorama informatico?
  I: /* l'attuale panorama informatico */
------------------------------------------------