La surcharge d'opérateurs sous Delphi 2006 Win32

Testé sous Xp et Delphi 2006 update 2 - hotfix 10.

I-A. Les sources▲

La surcharge d'un opérateur, ou polymorphisme ad hoc, permet de redéfinir son action afin qu'il exécute une fonction spécifiée lorsqu'il est utilisé avec un type d'enregistrement particulier, et ce avec Delphi 2006 sous Win32, Delphi .NET proposant en plus la surcharge d'opérateur pour les classes.

Ainsi l'ajout de deux enregistrements devient sémantiquement possible :

TMonRecord = record
    Champ1: Integer;
   ...
 end;
 
var RecordA, RecordB : TMonRecord;
    Resultat: TMonRecord;
begin
 RecordA.Champ1:=10;
 RecordB.Champ1:=11;
 RecordA:=RecordA+RecordB;
 Resultat:=RecordA+RecordB;
...

Les opérateurs surchargés remplacent avantageusement les appels de fonction (c'est ce que l'on pourrait appeler du « sucre syntaxique »).
Ce sucre syntaxique facilite l'écriture de code pour les utilisateurs de vos enregistrements en simplifiant leur usage.

Avant de débuter rappelons ce qu'est un opérateur, voici un extrait de l'aide de Delphi à ce sujet :
"Les opérateurs agissent comme des fonctions prédéfinies faisant partie du langage Delphi. Ainsi, l'expression (X + Y) est construite à partir des variables X et Y (appelées des opérandes) et avec l'opérateur + ; quand X et Y représentent des entiers ou des réels, (X + Y) renvoie leur somme.
Les opérateurs sont @, not, ^, *, /, div, mod, and, shl, shr, as, +, -, or, xor, =, >, <, <>, <=, >=, in et is. Les opérateurs @, not et ^ sont des opérateurs unaires (n'utilisant qu'un seul opérande). Tous les autres opérateurs sont binaires (ils utilisent deux opérandes), à l'exception de + et - qui peuvent être unaires ou binaires. Un opérateur unaire précède toujours son opérande (par exemple -B) à l'exception de ^ qui suit son opérande (par exemple, P^). Un opérateur binaire est placé entre ses opérandes (par exemple, A = 7).

Certains opérateurs se comportent différemment selon le type des données transmises. Ainsi, not effectue une négation bit à bit pour un opérande entier et une négation logique pour un opérande booléen. De tels opérateurs apparaissent dans plusieurs des catégories indiquées plus bas. À l'exception de ^, is et in, tous les opérateurs acceptent des opérandes de type Variant. Les sections suivantes supposent une certaine connaissance des types de données Delphi. Pour davantage d'informations sur la priorité des opérateurs dans les expressions complexes, voir Règles de priorité des opérateurs…"

Sous Delphi Win32 :
Seuls les enregistrements avancés peuvent utiliser la surcharge d'opérateurs. Voici ce que nous dit l'aide de Delphi à ce sujet :

• En plus des types d'enregistrements traditionnels, le langage Delphi autorise des types d'enregistrements plus complexes, similaires à des classes.
• En plus des champs, les enregistrements peuvent avoir des propriétés et des méthodes (incluant les constructeurs), des propriétés de classe, des méthodes de classe, des champs de classe et des types imbriqués.
• Les enregistrements ne prennent pas en charge l'héritage.
• Les enregistrements peuvent contenir une partie variable alors que les classes ne le peuvent pas.
• Les enregistrements sont des types valeur, copiés par affectation, transmis par valeur, et alloués sur la pile à moins qu'ils ne soient déclarés globalement ou alloués explicitement au moyen des fonctions New et Dispose. Les classes sont des types référence ; elles ne sont pas copiées par affectations, elles sont transmises par référence et sont allouées sur le tas.
• Les enregistrements permettent la surcharge d'opérateurs sur les plates-formes Win32 et .NET ; les classes permettent la surcharge d'opérateurs uniquement pour .NET.
• Les enregistrements sont construits automatiquement, en utilisant un constructeur par défaut sans argument, alors que les classes doivent être construites explicitement. Comme les enregistrements ont un constructeur par défaut sans argument, aucun constructeur d'enregistrement défini par l'utilisateur ne doit avoir de paramètre.
• Les types enregistrement ne peuvent pas avoir de destructeurs.
• Les méthodes virtuelles (celles spécifiées par les mots-clés virtual, dynamic et message) ne peuvent pas être utilisées dans les types enregistrement.
• À la différence des classes, les types enregistrement sur la plate-forme Win32 ne peuvent pas implémenter d'interfaces ; toutefois, les enregistrements sur la plate-forme .NET peuvent implémenter des interfaces."

À quoi j'ajouterai ces remarques.

• L'usage de méthodes de classe dans les records avancées nécessite la directive static (dans ce cas le compilateur ne gère pas de paramètre self dans les appels de méthode).
• Vous pouvez utiliser au sein d'une déclaration d'enregistrement le nom du type en cours de définition, mais uniquement dans les signatures de méthodes. Cela permet de le référencer avant qu'il ne soit effectivement défini.
• La directive overload est implicite.
• Plus d'informations…

Sous Delphi .NET 1.1 :
Les classes supportent la surcharge d'opérateurs et les interfaces peuvent être déclarées dans la définition d'un enregistrement. Très peu de classes du .NET Framework ont des opérateurs surchargés, mais la plupart des types valeur en ont.

L'aide en ligne nous propose un tableau contenant les informations suivantes :

Dans les signatures présentées plus avant les termes type et resultType renverront le plus souvent au nom du type de votre enregistrement. Notez que les opérateurs de conversion utiliseront forcément d'autres types, mais au moins celui du record manipulé.

Ce qui permettra les écritures suivantes, impliquant un type record et un type Integer :

RecordB:=10;
 RecordA:=RecordB+10;

Notez qu'il est tout à fait possible de surcharger plusieurs fois un opérateur :

RecordA:=RecordB+10; //Opérateur Add pour un entier
 RecordA:=RecordB+'10'; //Opérateur Add pour une chaine de caractères
 RecordA:=RecordB+RecordB; //Opérateur Add pour le type TMonRecord

D'après la documentation de Delphi :
« En règle générale, les opérateurs ne doivent pas modifier leurs opérandes. À la place, ils renvoient une nouvelle valeur, construite en effectuant l'opération sur les paramètres. »

V-A. Opérateurs unaires▲

TMonRecord = record
    Champ1: Byte;
    class operator Negative(const Value: TMonRecord): TMonRecord;
 end;
...
class operator TMonRecord.Negative(const Value: TMonRecord): TMonRecord;
begin
  Result.Champ1:=-Value.Champ1;
end;

V-B. Opérateurs binaires▲

TMonRecord = record
    Champ1: Byte;
    class operator Add(a: TMonRecord; b: TMonRecord): TMonRecord;
 end;

V-C. Opérateurs de comparaison▲

class operator TMonRecord.Equal(a, b: TMonRecord): Boolean;
begin
 Result:=A.Champ1=b.Champ1;
end;

V-D. Opérateurs de conversion▲

Writeln('Resultat=',RecordA);

Type illégal dans l'instruction Write/Writeln (E2054)

// Conversion explicite de TMonRecord en Integer
class operator TMonRecord.Explicit(a: TMonRecord): Integer;
begin
  Result:=a.Champ1;
end;

Writeln('Resultat=',Integer(RecordA));

RecordA:=10;

  Types incompatibles : 'TMonRecord' et 'Integer'

class operator TMonRecord.Implicit(a: Integer): TMonRecord;
begin
   Result.Champ1:=a;
end;

//Ici il s'agit de la conversion implicite du type TMonRecord vers une variable de type Integer
class operator TMonRecord.Implicit(a: TMonRecord): Integer;
begin
  Result:=a.Champ1;
end;

class operator TMonRecord.Implicit(a: TMonRecord): String;
begin
  Result:=IntToStr(a.Champ1);
end;
...
 Chaine:="Valeur de l''enregistrement"+RecordA;

TMonRecord = record
    Champ1: Integer;
     //A éviter :  Déclarer les deux opérateurs à l'identique
       // Conversion explicite de TMonRecord en Integer
    class operator Explicit(a: TMonRecord): Integer;
       // Conversion implicite de TMonRecord en Integer
    class operator Implicit(a: TMonRecord): Integer;
 end;

La définition d'opérateurs se prête bien à l'usage de la directive inline. Voyons ce que nous dit l'aide en ligne de Delphi 2006 à son sujet :
« Pour améliorer les performances, le compilateur Delphi permet le balisage des fonctions et procédures à l'aide de la directive inline. Si une fonction ou procédure répond à certains critères, le compilateur insère directement le code au lieu de générer un appel. L'utilisation de cette directive induit une optimisation des performances pouvant se traduire par un code plus rapide, mais elle présente des inconvénients en termes d'espace. En effet, elle entraîne toujours la création d'un fichier binaire plus volumineux par le compilateur. »

class operator TMonRecord.Negative(const Value: TMonRecord): TMonRecord;inline;
begin
  Result.Champ1:=-Value.Champ1;
end;

Exemple avec {$INLINE OFF} :

Project1.dpr.102: Resultat:=RecordA+RecordB;
00409160 8B1524E24000     mov edx,[$0040e224]
00409166 A120E24000       mov eax,[$0040e220]
0040916B E890F8FFFF       call TMonRecord.&op_Addition
00409170 A328E24000       mov [$0040e228],eax

Exemple avec {$INLINE ON} :

Project1.dpr.102: Resultat:=RecordA+RecordB;
00409160 A120E24000       mov eax,[$0040e220]
00409165 030524E24000     add eax,[$0040e224]
0040916B A32CE24000       mov [$0040e22c],eax
00409170 A12CE24000       mov eax,[$0040e22c]
00409175 A328E24000       mov [$0040e228],eax

Extrait de la documentation de Delphi 2006 :

Dans des expressions complexes, les règles de priorité déterminent l'ordre dans lequel les opérations sont effectuées.

Priorité des opérateurs

Un opérateur de priorité plus élevée est évalué avant un opérateur de priorité plus basse, les opérateurs de même priorité étant évalués à partir de la gauche. Ainsi, l'expression :
  X + Y * Z
multiplie Y par Z, puis ajoute X au résultat ; * est évaluée en premier, car sa priorité est supérieure à celle de +. Mais
  X - Y + Z
commence par soustraire Y à X puis ajoute Z au résultat : - et + ayant la même priorité, l'opération de gauche est effectuée en premier. Vous pouvez utiliser des parenthèses pour redéfinir ces règles de priorité. Une expression entre parenthèses est tout d'abord évaluée puis traitée comme un seul opérande. Par exemple,
  (X + Y) * Z
multiplie Z par la somme de X et Y. Les parenthèses sont parfois nécessaires dans des situations où, au premier regard elles ne semblent pas utiles. Par exemple, soit l'expression :
  X = Y or X = Z
L'interprétation voulue est manifestement :
  (X = Y) or (X = Z)
Néanmoins, sans parenthèses, le compilateur respecte les règles de priorité des opérateurs et l'interprète comme :
  (X = (Y or X)) = Z
ce qui provoque une erreur de compilation sauf si Z est un booléen. Les parenthèses rendent souvent le code plus simple à écrire et à lire même quand elles sont, techniquement parlant, inutiles. Ainsi le premier exemple peut également s'écrire :
  X + (Y * Z)
Ici, les parenthèses ne sont pas nécessaires pour le compilateur, mais elles épargnent au programmeur et au lecteur la nécessité de réfléchir à la priorité des opérateurs.

VII-A. Commutativité▲

RecordA:=RecordB+10; //Opérateur Add pour le type integer
 RecordA:=10+RecordB; //Opérateur Add pour le type integer

TMonRecord = record
    Champ1: Integer;
     //RecordA:=RecordB+10;
    class operator Add(a: TMonRecord; b: Integer): TMonRecord;inline;
     //RecordA:=10+RecordB;
    class operator Add(a: Integer; b: TMonRecord): TMonRecord;inline;
 ...

Les records avancés permettent à l'aide des opérateurs de faciliter la manipulation de nouveaux types et/ou de structures de données évoluées.

Le projet SurchargeOperateurs.dpr reprend les quelques lignes de code présentées dans ce tutoriel.

L'unité BigSetExample propose la gestion d'ensemble autour d'un type de base possédant plus de 256 valeurs.

Type
    TCouleur = (coBlanc, coBleu, coRouge, coVert, coNoir);
    TCouleurs = set of TCouleur;

TBigValue = $0000..$FFFF; //Valeur codée sur 2 octets, pas de MOVZX
 TBigValue = $0000..$10000; //Valeur codée sur 4 octets, MOVZX obligatoire

À noter l'unité BigSetD7Older pour Delphi versions 5 à 7.

L'exemple EssaisNullable.dpr propose une solution d'implémentation d'un type integer nullable. La gestion de la valeur NULL est simulée à l'aide de Nil et en respectant les règles suivantes :

• nil n'est jamais égal à nil ni différent de nil ;
• pour toute opération dont au moins un opérande vaut nil, le résultat est nil.

L'exemple contenu dans le fichier 23581_win32_operator_overloading_complex_numbers.ZIP, provenant de CodeCentral, propose l'implémentation d'un nombre complexe.