explication sur le mot clé "this" en c++

Bonjour,
je travail sur un exercice de surcharge des opérateurs en C++. Pour surcharger les opérateurs "==" "!=" pour des vecteurs de trois dimensions dont la classe est définit comme suite:

Code:

---

1 2 3 4 5 6 7

class vecteur3d { float x, y, z ; public : vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0) { x = c1 ; y = c2 ; z = c3 ; } } ;

---

ils ont proposé la solution suivante:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class vecteur3d { float x, y, z ; public : vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0) { x = c1 ; y = c2 ; z = c3 ; } int operator == (vecteur3d) ; int operator != (vecteur3d) ; } ; int vecteur3d::operator == (vecteur3d v) { if ( (v.x == x) && (v.y == y) && (v.z ==z) ) return 1 ; else return 0 ; } int vecteur3d::operator != (vecteur3d v) { return ! ( (*this) == v ) ; }

---

SVP je demande des explications sur le mot clé "*this" représente quoi exactement
et merci

http://en.cppreference.com/w/cpp/language/this
this est un pointeur sur l'objet courant.
*this est donc une référence sur l'objet courant.
Toute méthode non statique d'une instance d'objet dispose d'un paramètre implicite correspondant à l'objet courant.

Quand vous écrivez :

Code:

---

x.foo(y)

---

Vous passez à la méthode "foo" de la classe de l'instance de x un paramètre "caché" correspondant à un pointeur sur le "x" du code précédent.

Avec votre opérateur "!=" le code :

Code:

---

x != y

---

"*this" sera égale à une référence sur la variable "x" et "v" sera égale à y.

P.S.: faites attention aux signatures de vos opérateurs, leurs paramètres devraient être passé par références constantes et pas par copie.

par définition, this est le pointeur vers l'objet sur lequel est appelée la fonction membre.

Si la fonction est une fonction membre constante de la classe/structure Bidule, alors this est un Bidule const*, sinon, c'est un Bidule*.
Il y a plein de remarques à faire sur ce code.

operator== devrait retourner un booléen.
Elle devrait aussi être une fonction libre (non membre) (implémentée comme friend inline?)
Edit: et comme dit Bacelar, les arguments devraient être des références constantes.

operator!= devrait retourner un booléen.
Elle aussi devrait être une fonction libre
Elle pourrait appeler plus explicitement operator==.
Edit: et comme dit Bacelar, les arguments devraient être des références constantes.

Le constructeur devrait appeler la liste d'initialisation, plutot que réaffecter les variables.
A priori, il devrait y avoir deux constructeurs, sans arguments par défaut. Cela empecherait la conversion automatique d'un entier en un vecteur3d, et empecherait les constructions partielles.

Sans template, ca donnerait ceci: (3 pour 3D, d pour double)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

class vecteur3d { private: double x, y, z; public : vecteur3d(): x(0), y(0), z(0) {} vecteur3d(double x, double y, double z): x(x), y(y), z(z) {}   friend inline bool operator==(vecteur3d const& a, vecteur3d const& b) { return (a.x == b.x) && (a.y == b.y) && (a.z == b.z); }     vecteur3d& operator+=(vecteur3d const& autre) { this->x += autre.x; y += autre.y; z += autre.z; return *this; } };   inline bool operator!=(vecteur3d const& a, vecteur3d const& b) {return !(a==b);} vecteur3d operator+(vecteur3d a, vecteur3d const& a) {return a += b;}

---

Dans ce code, l'opérateur + appelle l'opérateur += de a (qui est pris en copie!), avec b comme argument, exactement comme si on avait écrit a.operator+=(b);. Dans cet appel, this pointe sur a.
Du coup, *this est a, et la fonction retourne bien une référence sur l'objet qui est modifié.