Newsgroup: it.comp.lang.c++
Titolo: Problemi di Overload

Ciao a tutto l' NG.
Non è da molto che ho iniziato a programmare in C++ e molte cose
(soprattutto la programmazione ad oggetti) sono ancora un po' misteriose. Ho
un problema nell'overload dell'operatore [], o meglio nella crezione di una
classe Matrice. Vi spiego meglio:
quello che vorrei fare è una classe Matrice che mi permetta di gestire
matrici (creazione, distruzione, accesso ai dati...), ma che mi permetta di
usare la sintassi del C++ cioè
    myMatrix[i][j] = 3; oppure varX = myMatrix[i][j];
Il libro che ho acquistato (ammetto che è per principianti del C++) tratta
il problema per un array (e quindi per quello non ho problemi) ma quando
devo estenderlo ad una matrice non riesco a capire come fare.
Vi ringrazio molto per il vostro auito.
Marco
P.S. Se non sono stato abastanza chiaro fatemi sapere.

 ha scritto nel messaggio
news:%g6C5.65112$3R6.1...@news.infostrada.it...

Non è possibile in C++ ridefinire l'operatore [][] (doppio indicizzamento),
ma un workaround può essere questo:
class Riga
{
    // ...
    int & operator [] (int);
};
class Matrice
{
    // ...
    Riga & operator [] (int);
};
Nella classe Matrice gestisci un array di classi Riga, mentre nella classe
Riga gestisci un array di interi (o del tipo che ti serve mettere nella
matrice).
Quando usi matrice[n] ti viene restituito un reference a una classe Riga,
alla quale viene poi viene applicato il secondo operatore [] con una
chiamata come la tua.
In pratica, quando scrivi
Matrice m;
k = m[1][2];
ottieni l'equivalente di
Matrice m;
riga &r = m[1];
k = r[2];
e poiché il tutto viene fatto con riferimenti, ottieni esattamente
l'elemento che ti interessa.
Spero di essermi spiegato bene, mi è venuto in mente ora e non ho nemmeno
provato se funziona, ma dovrebbe ;-)
Massimo

     myMatrix[i][j] = 3; oppure varX = myMatrix[i][j];
Il problema e' affrontato in dettaglio nella Q/A 13.8 della FAQ list
di comp.lang.c++ (
http://www.cerfnet.com/~mpcline/c++-faq-lite/
).  La
risposta corta e' di usare l'operator(), definendo myMatrix(i,j) in
maniera opportuna.
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

Guardati le FAQ su 
www.programmazione.it
C'e` giusto cio` che cerchi.
Paolo
-------------------------------------------
  Paolo Marotta
 
http://web.tiscalinet.it/paolo_marotta/
-------------------------------------------

 > usare la sintassi del C++ cioè


 sbagliato?
No, ma il sito e' inaccessibile.  Ho trovato con Altavista un mirror
italiano: 
http://users.utu.fi/sisasa/oasis/cppfaq/index.html
 .
Comunque ecco il passo in questione:
==============================================================================
[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 parameters 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];
    }
Then you can access an element of Matrix m using m(i,j) rather than m[i][j]:
    main()
    {
      Matrix m;
      m(5,8) = 106.15;
      cout << m(5,8);
      // ...
