Discussion :

[monsrhf]

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 :

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

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 :

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

[bacelar]

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 :

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

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 :

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

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.

[ternel]

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 :

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
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é.