Discussion :

[CoyotteDundee]

Bonjour à toutes et tous,

Je commence à "jouer" avec les types génériques et j'ai un petit problème de syntaxe de déclaration avec Delphi Xe8.
J'ai simplifié le problème avec le code exemple suivant :

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
 
uses generics.collections;
 
type
  TBaseType<T> = class
  private
    procedure SetValue(const Value: T);
    protected
    FValue: T;
    public
    property Value: T read FValue write SetValue;
  end;
 
  TInt = class( TBaseType<integer> );
  TString = class( TBaseType<string> );
 
  TBaseList<T1:TBaseType<T>> = class( TObjectList<T1>)
   function DoSomething: boolean;
  end;
 
  TIntList = class( TBaseList<TInt> );

Comme on le voit, TBaseType est spécialisé en TInt et TString. Pas de soucis jusque là.
TBaseList est une liste basée du TObjectList implémentant une fonctionnalité supplémentaire.

Le problème se situe au niveau de la déclaration de TBaseList. (Ligne 17) Delphi se plaint : "Undeclared Identifier :'T'" ainsi que "Type parameter 'T' must be a class type".
J'ai essayé plusieurs variantes de déclaration sans trouver celle qui satisferait le compilateur.

Quelqu'un peut-il m'expliquer où se situe mon erreur ?

Merci d'avance,

Coyotte

[Papy214]

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
unit Unit2;
 
interface
 
uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
  System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;
 
type
  TForm2 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form2: TForm2;
 
implementation
 
{$R *.dfm}
 
uses generics.collections;
 
type
  TBaseType<T> = class
  private
    procedure SetValue(const Value: T);
  protected
    FValue: T;
  public
    property Value: T read FValue write SetValue;
  end;
 
  TInt = class(TBaseType<integer>);
  TString = class(TBaseType<string>);
 
  TBaseList<T> = class(TList<T>)
    function DoSomething: boolean;
  end;
 
  TIntList = class(TBaseList<TInt>);
 
  { TBaseType<T> }
 
procedure TBaseType<T>.SetValue(const Value: T);
begin
  FValue := Value;
end;
 
{ TBaseList<T1> }
 
function TBaseList<T>.DoSomething: boolean;
begin
  //
end;
 
procedure TForm2.Button1Click(Sender: TObject);
var
  L: TBaseList<TInt>;
begin
  L := TBaseList<TInt>.Create;
  L[L.Add(TInt.Create)].Value := 12;
  ShowMessage(IntToStr(L.First.Value));
  L.Free;
end;
 
end.

[CoyotteDundee]

Bonjour Papy,

Merci pour la réponse complète et rapide...
J'ai une petite contrainte supplémentaire par rapport à ton code :
Je souhaite que la liste TBaseList ne puisse gérer que des classes descendantes de TBaseType... Et c'est là que cela coince pour moi.

Par contre, très élégante la construction

Code :

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

L[L.Add(TInt.Create)].Value := 12;

Je n'y avait jamais pensé...

Coyotte

[ShaiLeTroll]

Lorsque je suis passé de D7 à BCB2007 puis XE3, j'ai découvert les templates : STL list<> et VCL TList<>
A mon retour en Delphi XE2, j'ai tenté aussi les génériques Delphi, je crois que le sujet "Problème d'héritage avec les génériques."
c'est exactement le même soucis d'imbrication de type générique

Contraintes dans les génériques

Au mieux, tu peux forcer un type classe mais un type de class générique précise

Code :

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

TBaseList<T: class> = class(TObjectList<T>)

tu peux créer un super ancêtre non générique qui forcera la chaine

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
type
  TBaseTypeAncestor = class abstract(TObject);
 
  TBaseType<T> = class(TBaseTypeAncestor)
  private
    procedure SetValue(const Value: T);
  protected
    FValue: T;
  public
    property Value: T read FValue write SetValue;
  end;
 
  TInt = class( TBaseType<integer> );
  TString = class( TBaseType<string> );
 
  TBaseList<T: TBaseTypeAncestor> = class(TObjectList<T>)
   function DoSomething: boolean;
  end;
 
  TIntList = class(TBaseList<TInt>);
  TUncompiledList = class( TBaseList<TObject> );
 
procedure TZooThomVCLMainForm.btn1Click(Sender: TObject);
var
  L: TIntList;
  LU: TUncompiledList;
begin
  L := TIntList.Create(True);
  try
    L[L.Add(TInt.Create)].Value := 12;
    ShowMessage(IntToStr(L.First.Value));
  finally
  end;
  L.Free();
 
  LU := TUncompiledList.Create(True);
  LU.Free();
end;

[CoyotteDundee]

Super !
Merci ShaiLeTroll
J'ai une base pour démarrer maintenant...
Je marque le sujet comme étant résolu.

Merci à vous deux,

Coyotte

[Papy214]

pas testé mais ça doit le faire

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
26
 
uses generics.collections;
 
type
 
  IBaseType = Interface
 
  End;
 
  TBaseType<T> = class(TInterfacedObject, IBaseType)
  private
    procedure SetValue(const Value: T);
  protected
    FValue: T;
  public
    property Value: T read FValue write SetValue;
  end;
 
  TInt = class(TBaseType<Integer>, IBaseType);
  TString = class(TBaseType<string>, IBaseType);
 
  TBaseList<T: IBaseType, constructor> = class(TList<T>)
    function DoSomething: boolean;
  end;
 
  TIntList = class(TBaseList<TInt>);

Testé, ça fonctionne

[CoyotteDundee]

Merci Papy,

En tout cas, ça compile...
J'ai donc deux options pour résoudre mon problème, ce qui est tout de même assez confortable

Question :
Pourquoi re-déclares-tu IBaseType dans les déclarations de TInt et TString ?
Cette interface est déjà associée à l'ancêtre TBaseType, non ?
Il y a-t-il une raison particulière pour ce faire ?


Coyotte

[Papy214]

aucune raison, je suis juste allé un peu trop vite dans mon écriture ... tu peux les enlever

[CoyotteDundee]

...C'est bien ce que laissait à penser mon test... :-)

L'usage de l'interface permet de s'affranchir de l'obligation d'héritage de base pour toutes les classes manipulées, ce qui peut être un avantage dans certains cas.
Je vais pouvoir retourner plancher sur ma structure de classes qui va drôlement être simplifiée maintenant.

Merci,

Coyotte