Surcharge d'opérateurs
Remonter à Classes et objets - Index
Cette rubrique décrit les méthodes des opérateurs de Delphi et comment les surcharger.
A propos de la surcharge d'opérateurs
Delphi pour Win32 autorise la surcharge de certaines fonctions (ou "opérateurs") dans les déclarations d'enregistrement. Le nom de la fonction opérateur correspond à une représentation symbolique dans le code source. Par exemple, l'opérateur Add correspond au symbole +. Le compilateur génère un appel à la surcharge appropriée, en faisant correspondre le contexte (c'est-à-dire le type de retour et le type des paramètres utilisés dans l'appel) à la signature de la fonction opérateur. Le tableau suivant énumère les opérateurs Delphi pouvant être surchargés :
| Opérateur | Catégorie | Signature de déclaration | Mappage de symbole |
|---|---|---|---|
|
Implicit |
Conversion |
Implicit(a : type) : resultType; |
transtypage implicite |
|
Explicit |
Conversion |
Explicit(a: type) : resultType; |
transtypage explicite |
|
Negative |
Unaire |
Negative(a: type) : resultType; |
- |
|
Positive |
Unaire |
Positive(a: type): resultType; |
+ |
|
Inc |
Unaire |
Inc(a: type) : resultType; |
Inc |
|
Dec |
Unaire |
Dec(a: type): resultType |
Dec |
|
LogicalNot |
Unaire |
LogicalNot(a: type): resultType; |
not |
|
BitwiseNot |
Unaire |
BitwiseNot(a: type): resultType; |
not |
|
Trunc |
Unaire |
Trunc(a: type): resultType; |
Trunc |
|
Round |
Unaire |
Round(a: type): resultType; |
Round |
|
Equal |
Comparaison |
Equal(a: type; b: type) : Boolean; |
= |
|
NotEqual |
Comparaison |
NotEqual(a: type; b: type): Boolean; |
<> |
|
GreaterThan |
Comparaison |
GreaterThan(a: type; b: type) Boolean; |
> |
|
GreaterThanOrEqual |
Comparaison |
GreaterThanOrEqual(a: type; b: type): resultType; |
>= |
|
LessThan |
Comparaison |
LessThan(a: type; b: type): resultType; |
< |
|
LessThanOrEqual |
Comparaison |
LessThanOrEqual(a: type; b: type): resultType; |
<= |
|
Add |
Binaire |
Add(a: type; b: type): resultType; |
+ |
|
Subtract |
Binaire |
Subtract(a: type; b: type) : resultType; |
- |
|
Multiply |
Binaire |
Multiply(a: type; b: type) : resultType; |
* |
|
Divide |
Binaire |
Divide(a: type; b: type) : resultType; |
/ |
|
IntDivide |
Binaire |
IntDivide(a: type; b: type): resultType; |
div |
|
Modulus |
Binaire |
Modulus(a: type; b: type): resultType; |
mod |
|
LeftShift |
Binaire |
LeftShift(a: type; b: type): resultType; |
shl |
|
RightShift |
Binaire |
RightShift(a: type; b: type): resultType; |
shr |
|
LogicalAnd |
Binaire |
LogicalAnd(a: type; b: type): resultType; |
and |
|
LogicalOr |
Binaire |
LogicalOr(a: type; b: type): resultType; |
or |
|
LogicalXor |
Binaire |
LogicalXor(a: type; b: type): resultType; |
xor |
|
BitwiseAnd |
Binaire |
BitwiseAnd(a: type; b: type): resultType; |
and |
|
BitwiseOr |
Binaire |
BitwiseOr(a: type; b: type): resultType; |
or |
|
BitwiseXor |
Binaire |
BitwiseXor(a: type; b: type): resultType; |
xor |
Aucun opérateur autre que ceux de ce tableau ne peut être défini sur une classe ou un enregistrement.
Les méthodes d'opérateurs surchargés ne peuvent pas être référencées par nom dans le code source. Pour accéder à une méthode d'opérateur spécifique d'une classe ou d'un enregistrement spécifique, vous devez utiliser des transtypages explicites sur tous les opérandes. La liste des membres d'une classe ou d'un enregistrement ne comporte pas d'identificateur d'opérateur.
Il n'existe aucune hypothèse concernant les propriétés distributives ou commutatives de l'opération. Pour les opérateurs binaires, le premier paramètre est toujours l'opérande gauche et le second paramètre l'opérande droit. En l'absence de parenthèses explicites, l'associativité est supposée être de gauche à droite.
La résolution des méthodes d'opérateurs s'effectue par l'union d'opérateurs accessibles des types utilisés dans l'opération (y compris les opérateurs inherited). Pour une opération impliquant deux types différents (A et B), si le type A a une conversion implicite en B et B a une conversion implicite en A, cela entraîne une ambiguïté. Les conversions implicites ne doivent intervenir que lorsque cela est absolument nécessaire, et la réflexivité doit être évitée. Il est préférable de laisser le type B se convertir implicitement lui-même en type A et laisser le type A n'avoir aucune connaissance du type B (ou vice versa).
En règle générale, les opérateurs ne doivent pas modifier leurs opérandes. A la place, ils renvoient une nouvelle valeur, construite en effectuant l'opération sur les paramètres.
Les opérateurs surchargés sont utilisés plus souvent dans les enregistrements (c'est-à-dire les types de valeur).
Déclaration des surcharges d'opérateurs
Les surcharges d'opérateurs sont déclarées dans des classes ou des enregistrements avec la syntaxe suivante :
type
typeName = record
class operator conversionOp(a: type): resultType;
class operator unaryOp(a: type): resultType;
class operator comparisonOp(a: type; b: type): Boolean;
class operator binaryOp(a: type; b: type): resultType;
end;
L'implémentation des opérateurs surchargés doit aussi inclure la syntaxe class operator :
class operator typeName.conversionOp(a: type): resultType; class operator typeName.unaryOp(a: type): resultType; class operator typeName.comparisonOp(a: type; b: type): Boolean; class operator typeName.binaryOp(a: type; b: type): resultType;
Voici quelques exemples d'opérateurs surchargés :
type
TMyRecord = record
class operator Add(a, b: TMyRecord): TMyRecord; // Addition of two operands of type TMyRecord
class operator Subtract(a, b: TMyRecord): TMyRecord; // Subtraction of type TMyRecord
class operator Implicit(a: Integer): TMyRecord; // Implicit conversion of an Integer to type TMyRecord
class operator Implicit(a: TMyRecord): Integer; // Implicit conversion of TMyRecordto Integer
class operator Explicit(a: Double): TMyRecord; // Explicit conversion of a Double to TMyRecord
end;
// Example implementation of Add
class operator TMyRecord.Add(a, b: TMyRecord): TMyRecord;
begin
// ...
end;
var
x, y: TMyRecord;
begin
x := 12; // Implicit conversion from an Integer
y := x + x; // Calls TMyRecord.Add(a, b: TMyRecord): TMyRecord
b := b + 100; // Calls TMyRecord.Add(b, TMyRecord.Implicit(100))
end;