Discussion :

[corpacoeur]

Soit la déclaration de l'enregistrement TCoords et de ses opérateurs de 'classe':
Note: Ne tiquez pas sur le fait que les déclarations implicites de la chaîne vers TCoords et de TCoords vers la chaîne ne soit pas "identique" ! Ce code est une version simplifiée permettant d'afficher mon souci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
type
  TCoords = record
    Col, Row: Integer;
    class operator Implicit(const s: string): TCoords;
    class operator Implicit(const Coords: TCoords): string;
    class operator Add(const A, B: TCoords): TCoords;
  end;
 
class operator TCoords.Add(const A, B: TCoords): TCoords;
begin
  Result.Col := A.Col + B.Col;
  Result.Row := A.Row + B.Row;
end;
 
class operator TCoords.Implicit(const Coords: TCoords): string;
begin
  Result := '(i, ' + IntToStr(Coords.Col) + ', '+IntToStr(Coords.Row) + ')';
end;
 
class operator TCoords.Implicit(const s: string): TCoords;
begin
  Result.Col := Ord(s[1]) - Ord('a');
  Result.Row := Ord(s[2]) - Ord('1');
end;

Et de son utilisation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
{...}
var
  Coords: TCoords;
begin
  Coords := 'e4';
  Memo1.Lines.Add('Col: ' + IntToStr(Coords.Col));
  Memo1.Lines.Add('Row: ' + IntToStr(Coords.Row));
  Memo1.Lines.Add('Algebraic (Implicit): ' + Coords);
  Memo1.Lines.Add('Algebraic (Explicit): ' + string(Coords));
  {...}

Le résultat est déroutant, le compilateur delphi résouds ce problème en transformant la chaîne 'Algebraic (Implicit): ' en TCoords, effectue l'addition avec Coords, puis retransforme le résultat en chaîne. D'où la disparition pure et simple de la chaîne et des coordonnées qui n'ont pas de sens à nos yeux.

La seule solution pour éviter ce genre de problème dans ma situation est d'utiliser l'opérateur de classe Explicite (transformation de la chaîne en TCoords) à la place, cependant, je ne peux plus faire d'affectation du genre Coords := 'e4', mais plutôt Coords := TCoords('e4').

Y'aurait-il un moyen de contourner ce "problème" en définissant, par exemple, un ordre de priorité dans l'utilisation des opérateurs de classe ? Par exemple, que si un des membres de l'évaluation est une chaîne, il effectue les opérations implicites de Coords en chaîne (et non de la chaîne en coords, puis l'addition et enfin la transformation en chaîne), en d'autre terme que la concaténation soit prioritaire sur "l'addition" de coordonnées.

[corpacoeur]

Désolé pour ce message inutile, ne pouvait pas le supprimer...

J'ai donc résolu mon problème, en déclarant deux autres opérateurs de classe Add,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
    {...}
    class operator Add(const A: string; B: TCoords): string;
    class operator Add(const A: TCoords; const B: string): string;
    {...}
 
{...}
class operator TCoords.Add(const A: string; B: TCoords): string;
begin
  Result := A + string(B);
end;
 
class operator TCoords.Add(const A: TCoords; const B: string): string;
begin
  Result := string(A) + B;
end;

Ce qui m'a permis de résoudre la gestion de priorité.