surcharge d'operateur en c++

[aminaa]

SALUT

class matrice {
     double *tab;    
     unsigned lgn, col;    // nb de lignes et colonnes
     public:
     
     matrice& operator=(matrice& m)
         {
             lgn = m.lgn; col = m.col;
             tab = new double[lgn*col];
             return *this;
         }
     };

je veux bien comrendre à quoi servent ces 3 lignes:

lgn = m.lgn; col = m.col;
             tab = new double[lgn*col];
             return *this;

et merci
-----

[defender19]

Salut,

Il s'agit de la surcharge de l'opérateur = pour la classe matrice, cela correspond à assigner à une matrice a, les valeurs de la matrice b.

ex :

matrice a;
matrice b(paramètres du constructeur...);

a=b;

ce qui est l'équivalent de a.operateur=(b), c'est un peu un constructeur par copie.

Les lignes :

lgn = m.lgn; // mets dans l'attribut lgn de a, la valeur de lgn de m
col = m.col; // pareil qu'au dessus mais pour l'attribut col
tab = new double[lgn*col]; // alloue le tableau de a avec une taille de lgn*col
return *this; // retourne un pointeur de l'objet en cours : a en somme. c'est comme ça que marche les opérateurs, ( cela assigne les valeurs modifiés à l'objet a ?)

Il manque par contre, je pense, la copie du tableau de b dans celui de a... seul l'allocation mémoire est réalisé la...
pour le return *this, d'autres répondront sûrement mieux que moi et pourront confirmer ou infirmer ce que j'ai dit au dessus.

[Paraboloide_Hyperbolique]

Bonsoir,

L'opérateur surchargé '=' est appelé quand on égale deux instantiations m1 et m2 de la classe matrice: m2 = m. Celui-ci est chargé de réallouer la mémoire de m2 et de recopier les données de m dans m2. Pour cela, il faut accéder aux données de m, ce qui se fait via l'opérateur '.'

Dans votre code, on a:

lgn = m.lgn; col = m.col; --> Recopier les valeurs des variables lgn et col de m dans les variables lgn et col de m2.

La suite du code n'est pas correcte, car elle mène à une fuite mémoire et ne copie pas les données de la variable tab de m dans la variable tab de m2.
La correction (qui peut être optimisée) est la suivante:

 matrice &operator=(const matrice &m)
{
if(this != &rhs) // Protection contre l'auto copie m = m
  {
  lgn = m.lgn; col = m.col;    // Copie des variables lgn et col.

  delete[] tab;                       // Suppression de la mémoire allouée à m2.
  tab = new double[lgn*col]; // Réallocation à la taille de la matrice m.

  // Copie des valeurs de la variables tab de m dans m2.
  for(unsigned i = 0; i < lgn*col; i++)
      tab[i] = m.tab[i];
  }

return (*this);
}