Définition d'opérateur

Un article de Wikipédia, l'encyclopédie libre.
(Redirigé depuis Surcharge des opérateurs)
Aller à : navigation, rechercher

La définition d'opérateur est une fonctionnalité offerte par certains langages de programmation qui permet d'utiliser des opérateurs (comme +, = ou ==) comme des fonctions ou des méthodes en les définissant 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 ou de méthode :

  • avec définition d'opérateurs : a + b * c ;
  • sans définition d'opérateurs : somme (a, produit (b, c)).

Lorsque les opérateurs sont des fonctions, on parle en général de surcharge d'opérateur, car l'implémentation est choisie en fonction du type des opérandes (on parle également de polymorphisme ad hoc). C'est notamment le cas en C++.

Tous les langages permettant la définition d'opérateur ne permettent pas la surcharge. Python, par exemple, ne supporte pas la surcharge, mais permet de définir des opérateurs via des méthodes spéciales.

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.

Utilisation[modifier | modifier le code]

En théorie, la définition des opérateurs permet de faciliter l'écriture et la relecture du code.

Par exemple, on peut définir l'opérateur * pour réaliser des multiplications de matrices ou dé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 définition 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[modifier | modifier le code]

La surcharge et la redéfinition 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 de redéfinition d'opérateur : 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[modifier | modifier le code]

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