Discussion :

[Jcpan]

Bonjour

les interfaces sous delphi, quel utilité, comment les utiliser,pourquoi doit on avoir ce type de déclaration ?

Code :

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

1
2
3
4
5
6
7
type
  IInterface = interface
    ['{00000000-0000-0000-C000-000000000046}']
    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
  end;

Après avoir fais un long tour sur les tuts ici et ailleurs j'ai compris que les interfaces sont faites pour l'héritage multiple, sauf je ne vois aucun héritage multiple, car je dois recréer un interface et cette dernière est abstraire d'où je dois réécrire mes procédures déclarées dans l'interface .
Enfin tout n'est pas clair pour moi .
je compte sur votre aide et vos exemples pour clarifier tout ceux-ci

Merci

[Paul TOTH]

Bonjour

les interfaces sous delphi, quel utilité, comment les utiliser,pourquoi dois on avoir ce type de déclaration ?

Code :

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

1
2
3
4
5
6
7
type
  IInterface = interface
    ['{00000000-0000-0000-C000-000000000046}']
    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
  end;

Après avoir fais un long tour sur les tuts ici et ailleurs j'ai comprisque les interfaces sont faites pour l'heritage multiple, sauf je ne vois auccun heritage multiple, car je dois recréer un interface et cette dernière est abstraire d'ou je dois réécrire mes procédures déclarées dans l'interface .
Enfin tout n'est pas clair pour moi .
je compte sur votre aide et vos exemple pour clarifier tout ce ci

Merci

NON ! l'héritage multiple n'existe PAS sous Delphi

Les interfaces permettent de regrouper un ensemble de méthodes d'une classe sous une forme définie par ladite interface, c'est tout

à quoi ça sert ? c'est simple, prend les Streams sous Delphi, tous les objets flux dérivent de TStream. Il est impossible de faire un "SaveToStream()" vers autrechose qu'un dérivé de TStream...alors qu'on pourrait très bien imaginer un TMemo qui afficherait un dump hexadécimal des données par exemple.

Si on veux faire ça, on va créer un TMemoStream dérivé de TStream qui pointera sur un TMemo qu'il alimentera. Si Delphi supportait l'héritage multiple on pourrait également créer une classe qui dériverait à la fois de TMemo et TStream...mais ça n'est pas possible sous Delphi.

Maintenant, une autre approche serait de ne pas utiliser SaveToStream qui attend un TStream mais SaveToIStream qui attend une interface IStream. Une telle interface ne fait référence à aucune implémentation, mais juste à une liste de méthodes nécessaire au bon fonctionnement du Save. Tout objet qui supporte cette interface, quelque soit ses ancêtres, pourra fonctionner avec cette méthode. On pourra alors créer une classe TMemoStream qui dérive de TMemo et qui implémente l'interface IStream.

D'autre part, les interfaces subissent un traitement particulier de la part de Delphi. A chaque fois qu'on fait référence à une interface, Delphi invoque automatiquement sa méthode _AddRef, et à chaque fois qu'une variable de type interface sort de la portée (une variable locale en fin de procédure, une variable interne à un objet détruit...ou encore une interface à laquelle on affecte "nil") c'est la méthode _Release qui est invoquée.

Si l'interface est une classe Delphi dérivée de TInterfacedObject et uniquement dans ce cas, l'objet est automatique détruit car TInterfacedObject invoque son destructor quand le compteur de référence tombe à zéro...dans tous les autres cas, cela dépendra de l'implementation qui est faite de _AddRef et _Release

[Jcpan]

pouvez vous rediger un exemple une exemple SVP

[Paul TOTH]

pouvez vous rediger un exemple une exemple SVP

voici deux approches différents d'un même problème, l'une par héritage, l'autre par interfaces :

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
 
type
 TFruit=class
  procedure Mange; virtual;
 end;
 TPomme=class(TFruit)
  procedure Mange; override;
 end;
 TRaisin=class(TFruit)
  procedure Mange; override;
 end;
 
procedure TPomme.Mange;
begin
 ShowMessage('Croc');
end;
 
procedure TRaisin.Mange;
begin
 ShowMessage('Splitch');
end;
 
procedure Manger(Fruit:TFruit);
begin
  Fruit.Mange;
end;

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
 
type
 IMangeable=Interface
  procedure Mange; 
 end;
 
 TFruit=TInterfacedObject
 end;
 
 TPomme=class(TFruit, IMangeable)
  procedure Mange; 
 end;
 
 TRaisin=class(TFruit, IMangeable)
  procedure Mange; 
 end;
 
 TVoiture=class(TInterfacedObject, IMangeable)
  procedure Mange; 
 end;
 
procedure TPomme.Mange;
begin
 ShowMessage('Croc');
end;
 
procedure TRaisin.Mange;
begin
 ShowMessage('Splitch');
end;
 
procedure TVoiture.Mange;
begin
  ShowMessage('Pas bon !');
end;
 
procedure Manger(Mangeable:IMangeable);
begin
  Mangeable.Mange;
end;

[Jcpan]

Merci
la procedure Mange doit etre abstraite, exact ?

Code :

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

1
2
3
type
 TFruit=class
  procedure Mange; virtual;abstract;

[Paul TOTH]

Merci
la procedure Mange doit etre abstraite, exact ?

Code :

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

1
2
3
type
 TFruit=class
  procedure Mange; virtual;abstract;

éventuellement...mais elle pourrait aussi répondre par défaut "hummm...c'est bon"

NB: la méthode Mange pourrait être virtuelle également dans le deuxième exemple, mais elle n'a pas besoin d'être héritée d'un ancêtre commun. Il suffit que chaque classe qui implémente IMangeable en possède une, que ce soit par héritage ou pas.

[Jcpan]

D'autre part, les interfaces subissent un traitement particulier de la part de Delphi. A chaque fois qu'on fait référence à une interface, Delphi invoque automatiquement sa méthode _AddRef,

_Addref incremente le Guid ?

[Aka Guymelef]

Non pas du tout.

Le guid est là pour donner un identifiant unique à ton interface. C'est très important notamment si ton interface s'utilise pour du COM.

AddRef et Release ne font que, respectivement, incrémenter et décrémenter un compteur (de référence) interne. Lorsque le compteur de référence tombe à 0, Delphi détruit l'instance de l'objet qui implémente ton interface.

[Paul TOTH]

Non pas du tout.

Le guid est là pour donner un identifiant unique à ton interface. C'est très important notamment si ton interface s'utilise pour du COM.

AddRef et Release ne font que, respectivement, incrémenter et décrémenter un compteur (de référence) interne. Lorsque le compteur de référence tombe à 0, Delphi détruit l'instance de l'objet qui implémente ton interface.

en effet, le GUID n'est qu'un IDentifiant Global Unique qui permet d'identifier une interface donnée (voir QueryInterface d'ailleurs à ce sujet).

Pour ce qui est de l'implémentation faite de AddRef et Release...je dirais que la libération lorsque le compteur tombe à zéro est probablement le comportement attendu...mais cela reste à la discrétion du développeur. Mais c'est en effet le cas de TInterfaceObject