Discussion :

[helmis]

Bonjour

avez vous testé la methode qui suit de liberation ?
(Tiré de http://www.delphi3000.com/articles/article_2888.asp?SK=

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
unit GarbageCollector;
 
interface
 
type
  ISafeGuard = type IUnknown;
 
// Use the Guard function to instantiate the object!
function Guard(Obj : TObject; out SafeGuard : ISafeGuard) : TObject;
 
implementation
 
type
  TSafeGuard = class(TInterfacedObject, ISafeGuard)
  private
    FObj : TObject;
  public
    constructor Create(Obj : TObject);
    destructor Destroy; override;
  end;
 
constructor TSafeGuard.Create(Obj : TObject);
begin
  FObj := Obj;
end;
 
destructor TSafeGuard.Destroy;
begin
  if Assigned(FObj) then
  begin
    FObj.Free;
    FObj := nil;
  end;
  inherited Destroy;
end;
 
function Guard(Obj : TObject; out SafeGuard : ISafeGuard) : TObject;
begin
  Result := Obj;
  SafeGuard := TSafeGuard.Create(Obj);  // Create the proxy obj.
end;
 
end.

Pour creer un objet on fait ainsi

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
 
 
 
  var obj : TMyObj;
      SafeGuard : ISafeGuard;
 
  obj := TMyObj(Guard(TMyObj.Create, SafeGuard));
 
 
 
 TMyObj descend  TObject

example:

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
 
 
 
{$APPTYPE CONSOLE}
program Test;
 
uses GarbageCollector;
 
{ --- Test class --- }
type
  TTest = class(TObject)
  public
    constructor Create;
    destructor Destroy; override;
 
    procedure Test;
  end;
 
{ ---- Test members --- }
constructor TTest.Create;
begin
  WriteLn('Create()');
end;
 
destructor TTest.Destroy;
begin
  WriteLn('Destroy()');
  inherited;
end;
 
procedure TTest.Test;
begin
  WriteLn('Test()');
end;
{ ---- End Of Test members --- }
 
{ ---- Test Procedure --- }
 
procedure TestProc;
var SafeGuard : ISafeGuard;
    obj : TTest;
begin
  obj := TTest(Guard(obj.Create, SafeGuard)); // Create!
  obj.Test;
  { Notice that we are not explicitlly destroying the object here! }
end;
{ ---- End Of Test Procedure --- }
 
 
begin
  TestProc;
end.

Est ce efficace ?

[chaplin]

Ton exemple fonctionne qu'avec un type de constructor : Create.

Comment tu fais pour les autres classes qui admettent un ou plusieursparamètre à l'entré, comme tous les descendants de Tcomponent qui prennent justement un objet comme conteneur.

D'ailleurs, si on réfléchit bien à la mécanique employée par Delphi, si on ne fait pas appel directement au constructor, on s'appeçoit que Delphi se charge automatiquement de libérer les ressources quand on fait du pur développement RAD, c'est à dire quand on met des composants sur la fiche ou dans le datamodule. Autrement dit, chaque fois qu'on pose un composant sur une fiche, c'est équivalent à faire une instanciation de classe.

Donc faire du RAD à 100%, c'est faire du safe garbage collector .

[Paul TOTH]

Ton exemple fonctionne qu'avec un type de constructor : Create.

Comment tu fais pour les autres classes qui admettent un ou plusieursparamètre à l'entré, comme tous les descendants de Tcomponent qui prennent justement un objet comme conteneur.

D'ailleurs, si on réfléchit bien à la mécanique employée par Delphi, si on ne fait pas appel directement au constructor, on s'appeçoit que Delphi se charge automatiquement de libérer les ressources quand on fait du pur développement RAD, c'est à dire quand on met des composants sur la fiche ou dans le datamodule. Autrement dit, chaque fois qu'on pose un composant sur une fiche, c'est équivalent à faire une instanciation de classe.

Donc faire du RAD à 100%, c'est faire du safe garbage collector .

Ce n'est pas exact

le principe de cette unité est d'associé une instance objet à une Interface...l'interface étant libérée automatiquement par Delphi, son implémentation libérant son objet associé, les deux sont détruits automatiquement.

Tu pourrais très bien faire ceci :

Code :

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

1
2
3
4
5
6
 
var SafeGuard : ISafeGuard;
    obj : TButton;
begin
  obj := TButton(Guard(TButton.Create(nil), SafeGuard)); // Create!
end;

[chaplin]

Code :

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

function Guard(Obj : TObject; out SafeGuard : ISafeGuard) : TObject;

Autrement dit, même si on passe une instance de la classe, en plus il est possible d'appeler une méthode . Désolé maestro , j'avais pas en tête cette écriture, je me coucherais moins con ce soir .

Est ce que le problème du référencement est résolu, si A fait référence a B et inversement ?

[ShaiLeTroll]

Ce qui me choque le plus dans l'article de Delphi3000 c'est un honteux raccourci !

One of the top characteristics of C++ is that destructors are called automatically, In Object Pascal we must call destructors explicitlly.

Si l'on compare l'instanciation d'objet en C++ à celle du Delphi, on parle de l'instanciation dynamique donc celle fait avec New qui nécessite un appel explicite de Delete !

L'auteur sous-entend que la seule instanciation du c++ c'est l'instantiation automatique (ou statique), qui effectivement à la sortie du bloc de déclaration de l'objet, celui-ci n'ayant plus de portée, il sera implicitement libéré !

En C, on prend tellement l'habitude du malloc\free, qu'en C++, on prend très vite l'habitude du New\Delete ... d'ailleurs, le point " . " permet d'accéder au membre d'un objet comme en Delphi, et les créateurs du C++ on simplifier le " (*obj).membre " en " obj-membre ", on a d'ailleurs bcp plus de code avec -> car très peu développeur utilise l'instanciation statique ... ! le this->membre (équivalent du Self) par exemple montre que l'instanciation dynamique est priviligiée par les auteurs du langage !

En gros, les développeurs C++ on un garbage collector, et il ne l'utilise pas

[gb_68]

en C++, on prend très vite l'habitude du New\Delete ...

En C++, on essayera plutôt d'utiliser la raii, n'ayant pas de finally, pour être exception-safe .
L'usage du compteur de références de l'interface peut aussi aider à gérer un objet partagé (en C++ il existe(-ra) des shared/weak pointer).
Mais cela peut être un peu lourd dans le code (avoir l'instance + son interface) et il faut faire attention aux éventuels cycles comme pour les interfaces. Donc

Est ce que le problème du référencement est résolu, si A fait référence a B et inversement ?

non .

[chaplin]

le principe de cette unité est d'associé une instance objet à une Interface...l'interface étant libérée automatiquement par Delphi, son implémentation libérant son objet associé, les deux sont détruits automatiquement.

En tout cas merci pour l'explication sur l'interet du procédé, je n'avais pas compris la motivation d'utiliser l'interface, au moins c'est clair.