Nous avons commencé à réaliser une classe Point qui permet la recopie d'objet. Mais jusqu'à maintenant, nous avons été obligés de créer des méthodes telles que "Coincide" qui vérifie que deux points sont égaux. Nous aurions pu également réaliser une fonction membre qui ajoute un point à un autre :

class Point { int x; int y; public : Point(); Point(int a, int b); Point(const Point & pt); void Ajoute(const Point & pt); ... // D'éventuelles autres méthodes };

Vous sentez alors qu'il serait très appréciable et plus naturel de pouvoir faire quelque chose comme :

Point a(1,2); Point b(3,4); Point c; c = a + b;

C++ permet de réaliser une surdéfinition des opérateurs de base, comme "+", "-", "*", "/", "&", "^", etc. La liberté étant totale, vous pouvez faire réellement ce que vous voulez, par exemple une soustraction pour l'opérateur d'addition et inversement. Mais il est clair qu'il est plus que conseillé de respecter la signification de chacun des ces opérateurs.

Mettre en oeuvre les opérateurs simples est une opération assez rapide. Un exemple est utile pour vous montrer comment on fait :

class Point { int x; int y; public : Point(); Point(int a, int b); Point(const Point & pt); Point operator+(const Point & a) { Point p; p.x = a.x + x; p.y = a.y + y; return p; } ... // D'éventuelles autres méthodes };

Des explications sont nécessaires. Tout d'abord, vous remarquerez le "const Point & a ". Ceci signifie que l'on passe un point en paramètre (l'autre point de l'addition est en fait la classe appelante elle-même). Ce dernier est transmis par référence, afin d'éviter une recopie, lourde et moins rapide. Le "const" est optionnel mais permet d'éviter de modifier les paramètres et également autorise l'utilisation d'objets constants.
L'opérateur rend un Point. En fait, on rend en fin de méthode le point qui a été créé temporairement au départ et qui contient la somme des deux paramètres. Plus exactement, on rend une copie de cet objet, le retour de la fonction étant "Point", et non "Point&" ou "Point*". Ceci est normal. Il faut savoir que l'objet créé dans la méthode sera automatiquement détruit à la fin de cette dernière. On ne peut bien évidemment pas rendre l'adresse d'un objet qui sera détruit ! D'où la nécessité d'une recopie.

Ce que nous avons mis en oeuvre pour l'opérateur d'addition, nous pouvons en faire de même pour tous les autres opérateurs "simples". Quelques exemples :

class Point { int x; int y; public : Point(){} Point(int a, int b){ x=a; y=b; } Point operator +(const Point & a); Point operator -(const Point & a); int operator==(const Point & p); void Affiche() { // "this" est un pointeur sur la classe même cout << this << "->" << x << ", " << y << endl; } }; Point Point::operator +(const Point & a) { // Addition de 2 points Point p; p.x = x + a.x; p.y = y + a.y; return p; } Point Point::operator -(const Point & a) { // Soustraction de 2 points Point p; p.x = x - a.x; p.y = y - a.y; return p; } int Point::operator==(const Point & p) { // Egalité de 2 points (remplace "Coincide") if( x==p.x && y==p.y ) return 1; else return 0; } void main() { Point p(1,2); p.Affiche(); Point pp(3,4); pp.Affiche(); Point ppp = p+pp; ppp.Affiche(); if( p==pp ) cout << "p==pp" << endl; else cout << "p!=pp" << endl; p = ppp; p.Affiche(); pp = p-ppp; pp.Affiche(); if( p==ppp ) cout << "p==ppp" << endl; else cout << "p!=ppp" << endl; }

L'opérateur d'affectation "=" est assez particulier. En effet, nous retrouvons le même problème que lors de la construction par recopie : il est toujours possible d'effectuer une affectation entre deux objets (de même type), mais que se passe-t-il s'ils contiennent des pointeurs (cf. problématique de recopie) ! C'est pourquoi il est souvent important d'implémenter ce type d'opérateur.
Il n'est pas plus difficile à mettre en oeuvre :

#include class Vecteur { int *pVecteur; int nTaille; public : Vecteur(int); Vecteur(const Vecteur &); ~Vecteur(); int GetAt(int ind) { if( ind>=0 && ind return pVecteur[ind]; else return 0; } void SetAt(int ind, int val) { if( ind>=0 && ind pVecteur[ind]=val; } int Size(){ return nTaille; } Vecteur& operator =(const Vecteur & v); }; Vecteur::Vecteur(int Taille) { nTaille = Taille; pVecteur = newint[nTaille]; } Vecteur::Vecteur(const Vecteur & v) { nTaille = v.nTaille; pVecteur = newint[nTaille]; for( int i=0; i pVecteur[i]=v.pVecteur[i]; } Vecteur::~Vecteur() { delete pVecteur; } Vecteur& Vecteur::operator =(const Vecteur & v) { // On vérifie que les objets ne sont pas les mêmes ! if( this != &v ) { delete pVecteur; // Effacement du vecteur nTaille = v.nTaille; pVecteur = newint[nTaille]; // Allocation // Recopie des valeurs for( int i=0; i pVecteur[i]=v.pVecteur[i]; } return *this; } void main() { Vecteur *v; v = new Vecteur(10); for( int i=0; iSize(); i++ ) v->SetAt(i, i*i-i); Vecteur vv(5); vv = *v; vv.SetAt(0, 13); vv.SetAt(1, 13); vv.SetAt(2, 13); for( i=0; iSize(); i++ ) cout << v->GetAt(i) << " "; cout << endl; for( i=0; i cout << vv.GetAt(i) << " "; cout << endl; delete v; }

Cette fois-ci, nous rendons par contre une référence sur l'objet, car nous devons rendre la classe elle-même et non une copie, comme vous pouvez le comprendre !