Appeler la méthode Create indépendamment de constructeur

**Montor** · 24/07/2010, 22h31

Voici trois méthodes démontre comment appeler la méthode Create indépendamment de constructeur

Code :

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

var B:TButton;

Methode 1

Code :

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

1
2
3
4
5
Getmem(B,TButton.InstanceSize);
ZeroMem(B,TButton.InstanceSize);
PInteger(B)^ := Integer(TButton);
B.Create(Self);
B.Parent:=Self;

Methode 2

Code :

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

1
2
3
4
Getmem(B,TButton.InstanceSize);
TButton.InitInstance(B);
B.Create(Self);
B.Parent:=Self;

Methode 3

Code :

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

1
2
3
B:=TButton.NewInstance;
B.Create(Self);
B.Parent:=Self;

Standard

Code :

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

1
2
B:=TButton.Create(Self);
B.Parent:=Self;

**Just-Soft** · 25/07/2010, 07h47

Salut

merci MONTOR mais je crois que la méthode standard utilise elle même la 1ière technique, de même pour les deux autres méthodes qui, je crois, l'utilisent aussi.

En plus, le défi des concepteur de Delphi était de mettre du code prêt à l'emploi pour les utilisateur des composants Delphi. Par contre, je crois, que les développeurs de composants sous Delphi doivent connaitre impérativement les techniques de base telle que celles que tu présentes.

Cordialement.

**Montor** · 25/07/2010, 22h25

Oui effectivement c'est pour donner une idée et enlever la confusion autour de constructeur qui reste un peu flou pour certains et aussi pour répondre a l'obsession

Code :

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

Button1.Create

En réalité la Méthode 1 est déconseillée puisque les interfaces ne sont pas initiées mais explique la notion de instance

**sjrd** · 30/07/2010, 13h27

Les méthodes 1 et 2 ne sont pas correctes, car elles ne prennent pas en compte que les objets peuvent avoir surchargé NewInstance.

Pire, la méthode 1 est parfaitement fausse si la classe implémente au moins une interface (donc pour TButton c'est faux). C'est InitInstance qui se charge du boulot lié aux interfaces.

La méthode 3 n'est pas exactement équivalente à la 4. Il faudrait écrire :

Code :

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

1
2
3
4
5
6
7
8
9
B := TButton(TButton.NewInstance);
try
  B.Create(Self);
except
  B.Destroy;
  raise;
end;
 
B.Parent := Self;

Seule cette méthode peut être considérée comme une alternative valable. Mais son utilité est vraiment très rare. J'en ai un cas dans Sepi, mais c'est tout.

**sjrd** · 30/07/2010, 13h46

Dans le genre, j'en ai une bien dégueulasse. À nouveau, utilisée une et une seule fois dans Sepi. Elle ne fonctionne que pour les classes qui n'ont pas surchargé Destroy depuis TObject.

Le but étant de faire l'allocation de mémoire de l'objet sur la pile, et non sur le tas. Quand c'est la seule source d'allocation mémoire sur le tas dans un algorithme coûteux, ça peut améliorer sensiblement les performances. Mais c'est vraiment, vraiment à ne faire que dans des cas très rares !

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
type
  TMyObject = class(TObject)
    // ...
    constructor Create(AValue: Integer);
    // pas de destructor
  end;
 
procedure DoSomething;
var
  Size: Integer;
  Obj: TMyObject;
begin
  Size := TMyObject.InstanceSize;
  asm
        SUB     ESP, Size
        MOV     Obj, ESP
  end;
 
  TMyObject.InitInstance(Obj);
  try
    Obj.Create(3);
    // Do something with object Obj
  finally
    Obj.CleanupInstance;
  end;
 
  asm
        ADD     ESP, Size
  end;
end;

Je n'ai pas testé, mais ceci devrait fonctionner dans le cas où Destroy a été surchargée :

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
type
  TMyObject = class(TObject)
    // ...
    constructor Create(AValue: Integer);
    destructroy Destroy; override;
  end;
 
procedure DoSomething;
var
  Size: Integer;
  Obj: TMyObject;
begin
  Size := TMyObject.InstanceSize;
  asm
        SUB     ESP,Size
        MOV     Obj,ESP
  end;
 
  TMyObject.InitInstance(Obj);
  try
    Obj.Create(3);
     // Do something with object Obj
  finally
    asm
        MOV     EAX,Obj
        XOR     DL,DL
        MOV     ECX,[EAX]
        CALL    DWORD PTR [ECX + VMTOFFSET TObject.Destroy]
    end;
 
    Obj.CleanupInstance;
  end;
 
  asm
        ADD     ESP,Size
  end;
 end;

**Montor** · 31/07/2010, 23h09

Merci pour tes explications...bien sur il faut demander dans quelle contexte
on peut faire une telle utilisation ... dans mon cas je voulais créer Array Of Instance que je le trouve mieux que de utiliser le memorymanager

**sjrd** · 01/08/2010, 10h33

Oui effectivement, dans ce cas-là, tu ne peux pas les méthodes 3 ou 4. Mais c'est tout de même douteux

En relisant le sujet je remarque qu'on a complètement oublié un détail d'importance jusqu'ici : l'appel de la méthode AfterConstruction !

Normalement j'ai bien compris le mécanisme complet, et l'alternative complète au Create habituel serait :

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
B := TButton(TButton.NewInstance);
 
try
  B.Create(Self);
 
  try
    B.AfterConstruction;
  except
    B.BeforeDestruction;
    raise;
  end;
except
  CallDestroy(B, $81);
  raise;
end;
 
procedure CallDestroy(Obj: TObject; OuterMost: Shortint);
asm
        { -> EAX  Pointer to instance
             DL   Dealloc flag }
        MOV     ECX,[EAX]
        CALL    DWORD PTR [ECX + VMTOFFSET TObject.Destroy]
end;

Le $81 veut dire : ne pas appeler BeforeDestruction, mais appeler FreeInstance.
Il n'existe malheureusement pas de code pour dire : appeler BeforeDestruction mais pas FreeInstance.

Pour compléter le tout, un appel tel que :

Code :

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