surcharge d'opérateur d'accés

bonjour
tout le monde je solicite votre aide concernant la surcharge d'opérateur:
j'ai une classe matrice définit comme suit
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 template <typename T> class Matrix{ private: unsigned int n; unsigned int m; typedef T * pdata; pdata *ligne; public: T& operator[][](int i),(int j){ return ligne[i][j]; } ... };
je veux pouvoir obtenir l'élèment Aij de la façon suivante:A[i][j]
j'ai fait ceci
Code:

1 2 T& Matrix<T>::opetarot[][](int i),(int j){ return ligne[i][j];}
mais ça me donne rien si quelqu'un peux m'aider je lui serai très reconnaissant
cordialement

Code:

1 2 3 T& Matrix<T>::opetarot[][](int i),(int j){ return ligne[i][j];}
Sinon il ne me semble pas que l'opérateur [][] existe.
Tu ne peux pas rajouter d'opérateurs sans réécrire le compilateur.

Par contre tu peux redéfinir l'opérateur [] pour lui faire renvoyer une instance d'une classe particulière.
Et dans cette classe redéfinir l'opérateur [] pour lui faire renvoyer ta Matrix &

Salut,
Citation:
Envoyé par Neckara
Code:

1 2 3 T& Matrix<T>::opetaror[][](int i),(int j){ return ligne[i][j];}
Sinon il ne me semble pas que l'opérateur [][] existe.
Tu ne peux pas rajouter d'opérateurs sans réécrire le compilateur.
En effet :D

Citation:

Par contre tu peux redéfinir l'opérateur [] pour lui faire renvoyer une instance d'une classe particulière.
Et dans cette classe redéfinir l'opérateur [] pour lui faire renvoyer ta Matrix &

Encore exact :D

L'idéal est sans doute de créer une classe "Line" (ou "vector", pour suivre les termes mathématiques ;) ) qui s'occupe de gérer les lignes de ta matrice, et de faire en sorte que ta matrice manipule des tableaux de lignes.

Ainsi, l'opérateur [] de la matrice renvoie une référence (éventuellement constante) vers la ligne concernée et l'opérateur [] de la ligne renvoie une référence (éventuellement constante) vers l'élément concerné ;)

Ceci dit, il y a une autre solution qui mérite d'être envisagée:

Si ta matrice est destinée à être pleine, tu peux très bien considérer que, si tu as N lignes de M éléments, ta matrice doit, tout simplement, contenir N*M éléments :D

Cela peut énormément simplifier les choses parce que outre le fait d'éviter le recours à une classe intermédiaire (avec le risque que toutes les lignes ne comprennent pas le meme nombre d'éléments :aie:) et d'avoir à manipuler des pointeurs de pointeurs, elle permet de faciliter la gestion dynamique de la mémoire.

En outre, sur les matrice de tailles raisonnables, tous les éléments étant stockés de manière contigue en mémoire, il se peut qu'il tiennent tous dans une page mémoire, et cette méthode peut donc éviter les pertes de performances dues au "cache miss" ;)

La seule chose, c'est qu'il te faudra utiliser une petite formule pour accéder à un élément donné, mais, par chance, elle n'est pas vraiment compliquée :D

Si don, tu as une matrice composée de maxLigne et de maxColonnes, et que l'utilisateur essaye d'accéder à l'élément ligne, colonne, la formule pour y accéder est

Code:

Element(ligne, colonne) = Data( (Ligne*maxColonne) + colonne)

Du coup, plutôt que de redéfinir l'opérateur [], tu pourrais redéfinir l'opérateur () qui aurait, de plus, l'énorme avantage de "coller" d'avantage aux écritures mathématiques ;)

Au final, ta classe Matrix pourrait donc ressembler à quelque chose comme
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 template <typename T> { public: Matrix(size_t maxLines, size_t maxColumns):maxLines_(maxLines), maxColumns_(maxColumns), data_(new T[maxLines*maxColumns]) {} ~Matrix(){delete [] data_;} T & operator ()(size_t line, size_t column) { const Matrix * temp = this; return const_cast<T &>(temp(line, column)); } T const & operator() const { return data_[line * maxColumns + colum]; } private: T * data_; };
Nota: il serait même possible d'éviter le recours à l'allocation dynamique, mais je vais te laisser "digérer" tout cela à ton aise avant de te parler de cette solution ;)