Discussion :

[memoire.ph]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Neckara]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 &

[koala01]

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

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

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 ) 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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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