Surcharge des opérateurs

La surcharge statique d'opérateur (également connue sous le nom de polymorphisme ad-hoc) est une technique de programmation qui permet de donner un nouveau rôle aux opérateurs (comme +, = ou ==). Ceux-ci sont ainsi traités comme des fonctions et peuvent être définis ou redéfinis pour de nouveaux types de données. Les opérateurs ne sont pas nécessairement des symboles. Parfois la définition de nouveaux opérateurs est autorisée. Il s'agit généralement de sucre syntaxique, et peut facilement être émulé par des appels de fonction :

• avec surcharge : a + b * c
• sans surcharge : somme (a, produit (b, c))

Dans le cas où les opérateurs peuvent être appelés implicitement, ils deviennent plus utiles qu'esthétiques. C'est le cas avec l'opérateur to_s de Ruby, qui retourne une représentation chaîne d'un objet et avec les opérateurs de PostgreSQL, sur lesquels peuvent être définies des transformations mathématiques. PostgreSQL peut aussi employer de nombreuses optimisations sur les expressions qui utilisent ces opérateurs.

Le polymorphisme ad-hoc ne doit pas être confondu avec le polymorphisme d'inclusion des langages à objets, permis par l'héritage de classe et la redéfinition de méthode. La sélection de l'opérateur adéquat a lieu à la compilation dans le premier cas, à l'exécution dans le second.

Utilisation

En théorie, la surcharge des opérateurs permet de faciliter l'écriture et la relecture du code. Par exemple, on peut redéfinir l'opérateur * pour réaliser des multiplications de matrices ou redéfinir l'opérateur + pour additionner deux nombres complexes.

// Exemple avec des matrices
// ... les variables a et b sont initialisées et sont 2 matrices
Matrice c = a * b;

// Exemple avec des complexes
Complex i = new Complex(0, 1);
Complex un = new Complex(1, 0);
Complex r = i + un;

Aussi puissante qu'elle puisse être, la surcharge des opérateurs doit être toujours utilisée avec parcimonie pour ne pas perdre le lecteur d'un programme, d'autant plus qu'il est aisé de mal l'utiliser.

Critique

La surcharge des opérateurs a été critiquée parce qu'elle peut surprendre le lecteur d'un programme, en autorisant le programmeur à donner à un même opérateur des fonctionnalités subtilement différentes en fonction des types de leurs opérandes. L'utilisation en C++ de l'opérateur de décalage binaire << est un (mauvais) exemple caractéristique : l'expression

a << 1

retournera le double de la valeur de a (sans le modifier) s'il s'agit d'une variable entière, mais si a est un flot de sortie, alors cela déposera « 1 » dedans (et donc le modifiera).

Un autre exemple est l'erreur courante consistant à redéfinir un opérateur mathématique (comme +, l'opérateur d'addition) qui ne modifie pas son opérande de gauche, avec une fonction qui la modifie (confusion avec l'opérateur +=).

Cette critique peut être étendue aux langages à objets (du modèle objet avec classes) : la redéfinition d'une méthode permet au programmeur d'en modifier la sémantique ; aucune preuve formelle n'est applicable pour éviter ce problème.

Catalogue

• Langages qui acceptent la surcharge statique d'opérateurs et la déclaration de nouveaux opérateurs : SQL de PostgreSQL, Ruby, Haskell
• Langages qui acceptent la surcharge statique seulement : Ada, C++, C#, D, Delphi, Perl, Python
• Langages qui ne supportent pas la surcharge statique : C, Pascal, Visual Basic, Common Lisp, Java

• Portail de la programmation informatique