On aimerait pouvoir définir une addition sur les points:
 
 
 

Point p1,p2; Point p=p1+p2;
 
 
 

où l'addition sur les points donnerait pour p un point de position correspondant à la somme des 2 abcisses et des 2 ordonnées.
 
 
 
 
 

Il s'agit ici d'une nouvelle forme de polymorphisme (ou de surcharge)  mais portant ici non plus sur des fonctions, mais sur des opérateurs utilisés usuellement dans le langage. C++ permet une telle redéfinition . Il existe même deux approches possibles:
 
 
 
 
 
 
 
 
 
 
 
 
 
 

1) Utiliser une fonction membre de la classe

Class Point {

float x,y;

public:

Point( float x0, float y0) { x=x0; y=y0;}

Point operator+( Point &p2) {
return Point(x+p2.x,y+p2.y);
}

};

On utilise l'opérateur + comme spécifié ci-dessus.
 

On remarque que dans la liste d'arguments de l'opérateur +, il n'y a qu'un argument au lieu de deux (toujours un argument de moins si l'opérateur est défini par une fonction membre). En fait, le premier argument est déja connu, c'est celui sur lequel pointe le pointeur *this .
 

Que se passe-t-il réellement quand on écrit p=p1 + p2; ?

en fait, on exécute    p=p1.operator+(p2);
 

On voit que le traitement des deux arguments n'est pas du tout symétrique, ce qui peut occasionner de sérieux désagréments: une addition peut être définie dans un sens et pas dans l'autre, par exemple dans le cas où une conversion de type est nécessaire pour le deuxième argument.
 

Néanmoins, l'approche par la fonction membre est la seule possible pour les opérateurs suivants:
 

- l'opérateur d'affectation =
- l'opérateur d'indiçage []
- l'opérateur fonction ()
- l'opérateur d'indirection ->
- les opérateurs de conversion de type
 
 
 
 
 
 
 
 

2) Utiliser une fonction friend (n'appartenant donc pas à la classe)

En général, l'approche par la fonction friend évite les mauvaises surprises en traitant les deux arguments de manière symétrique.

class Point {
friend Point operator+(  Point &p1, Point &p2);
float x,y;

public:
Point( float x0, float y0) { x=x0; y=y0;}

};
 
 
 

inline Point operator+(Point &p1, Point &p2) {
return Point(p1.x+p2.x,p1.y+p2.y);
}
 
 

Que se passe-t-il réellement quand on écrit p=p1 + p2; ?

en fait, on exécute    p=operator+(p1,p2);
 

On peut ainsi redéfinir d'autres opérateurs, comme - , * , /, ==, ++, +=, <            (la liste n'est pas exhaustive)