Discussion :

[Jcpan]

Bonjour

tiré du tut de Fbeaulieu (que je remercie au passage)

La surcharge au moyen du couple virtual-override permet ce qu'on appelle des appels virtuels de méthodes. En fait,
lorsque vous appelez une méthode déclarée d'une classe et construire par une classe descendante de celle-ci, c'est
la méthode surchargée dans cette dernière qui sera exécutée

c'est quoi la difference entre virtual-override ?

je sais que si on veut surchager un fonction on utlise override exemple

mais virtual & Dynamic je vois pas.


par contre dans ce code j'ai pas utilisé override et tout c'est bien passé

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
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Buttons;
 
type
  TForm1 = class(TForm)
    SpeedButton1: TSpeedButton;
    procedure SpeedButton1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
  C1 = class
  procedure non();
  function oui():integer;
  end;
  C2 = class(C1)
  procedure non(rep : string);
  function oui():integer;
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
{ C1 }
 
procedure C1.non();
begin
  showmessage('Non');
end;
 
function C1.oui(): integer;
begin
  showmessage('Oui');
  result := 33;
end;
 
{ C2 }
 
procedure C2.non(rep : string);
begin
  inherited non();
end;
 
function C2.oui(): integer;
begin
inherited oui();
 result := 33;
end;
 
procedure TForm1.SpeedButton1Click(Sender: TObject);
var
C : C2;
begin
 C := C2.Create();
 C.oui();
 C.Free();
end;
 
end.

merci d'avance

[Jcpan]

ok compris

Mais bon sang mais c'est bien sûr !
Lorsqu'une méthode est écrite sans y ajouter le mot-clé override (ou un ou deux autres que nous allons voir tout de
suite), elle est dite statique, c'est-à-dire qu'elle n'est pas candidate à la surcharge. Ainsi, il ne sera pas possible de
la surcharger (mais de la redéfinir, nous y reviendrons). Bref, notre premier constructeur a été défini sans ce mot-clé,
et il est donc statique, et ne peut donc pas être surchargé

mais quelqu'un peut mettre en pratique l'exemple si dessus pour voir le resultat ?

[Dr.Who]

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
  TPlus = class
  public
    function vPlus: integer; virtual; abstract;
  end;
 
  TPlus1 = class(TPlus)
  public
    function vPlus: integer; override;
    function nvPlus: integer;    
  end;
 
  TPlus2 = class(TPlus1)
  public
    funtion vPlus: integer; override;
    function nvPlus: integer;
  end;
 
implementation
 
 
function TPlus1.vPlus: integer;
begin
  result := 1;
end;
 
function TPlus1.nvPlus: integer;
begin
  result := 1;
end;
 
function TPlus2.vPlus: integer; // retourne 2
begin
  result := inherited vPlus + 1;
end;
 
function TPlus2.nvPlus: integer; // retourne 2
begin
  result := 2;
end;

une methode virtuelle ou dynamique, est une methode qui vas pouvoir être dérivée dans une classe enfant.
les methodes qui ne sont pas marquée virtuelle ou dynamique seront écrasée dans la classe enfant, en cas de nomage de méthodes identiques.

constructeur et destructeur sont des methodes virtuelles, ainsi, on peux ajouter en initialisation et finalisation dans chaque classe enfant, en respectant les init et final des classes ancêtre, ce qui evite de réécrire tout le code du début à la fin.

le surchargement de méthodes est un concept inscrit dans le RAD (Rapid Application Development) et un principe fondamental de la POO.

[Dr.Who]

et avec un constructeur/destructeur :

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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
type
  // classBase est la classe de base pour tout nos futur objet
  // elle ne contient que le fonctionnement communs à tous ces derniers
  TClassBase = class
  private
    fPointer: pointer;
    fSize   : integer;
  protected
    property Ptr: pointer read fPointer;
    property Size: integer read fSize;
    constructor Create(aSize: integer); // ce constructeur n'est pas virtuel
                                        // il ne doit jamais être surchargé ni
                                        // visible dans le code "normal"
  public
    destructor Destroy; override;
  end;
 
  // TClass32 est une base conteneur de 32 bits (4 octets)
  TClass32 = class(TClassBase)
  public
    constructor Create; virtual; // son constructeur est virtuel
    property Ptr; // sa propriété Ptr est publique
  end;
 
  // TClass64 est une base conteneur de 64 bits (8 octets)
  TClass64 = class(TClassBase)
  public
    constructor Create; virtual; // son constructeur est virtuel
    property Ptr; // sa propriété Ptr est publique
  end;
 
  // TClass32Int est un conteneur pour un entier 32 bits signé
  // basé sur la classe TClass32
  TClass32Int = class(TClass32)
  private
    function GetInt: integer;
    procedure SetInt(value: integer);
  public
    property Int: integer read GetInt write SetInt;
    constructor Create; override; // on surcharge le constructeur de TClass32
  end;
 
  // TClass32Float est un conteneur pour un flottant 32 bits
  // basé sur la classe TClass32
  TClass32Float = class(TClass32)
  private
    function GetFloat: single;
    procedure SetFloat(value: single);
  public
    property Float: single read GetFloat write SetFloat;
    constructor Create; override;
  end;
 
  // TClass64Int est un conteneur pour un entier 64 bits
  // basé sur la classe TClass64
  TClass64Int = class(TClass64)
  private
    function GetInt: int64;
    procedure SetInt(value: int64);
  public
    property Int: int64 read GetInt write SetInt;
    constructor Create; override;
  end;
 
  // TClass64Float est un conteneur pour un flottant 64 bits
  // basé sur la classe TClass64
  TClass64Float = class(TClass64)
  private
    function GetFloat: double;
    procedure SetFloat(value: double);
  public
    property Float: double read GetFloat write SetFloat;
    constructor Create; override;
  end;
 
 
{ TClassBase }
 
constructor TClassBase.Create(aSize: integer);
begin
  // TClassBase se charge d'allouer la mémoire à fPointer
  fPointer := AllocMem(aSize);
  // et de sauvegarder sa taille
  fSize    := aSize;
end;
 
destructor TClassBase.Destroy;
begin
  // TClassBase se charge de :
  // mettre la memoire à 0
  ZeroMemory(fPointer, fSize);
  // et désalouer fPointer
  FreeMem(fPointer, fSize);
  inherited;
end;
 
{ TClass32 }
 
constructor TClass32.Create;
begin
  // invoque un TClassBase avec fPointer alloué à 4 octets (32bits)
  inherited Create(4);
end;
 
{ TClass64 }
 
constructor TClass64.Create;
begin
  // invoque un TClassBase avec fPointer alloué à 8 octets (64bits)
  inherited Create(8);
end;
 
 
{ TClass32Int }
 
constructor TClass32Int.Create;
begin
  // invoque un TClass32
  inherited;
  // l'initialise à 0
  SetInt(0);
end;
 
function TClass32Int.GetInt: integer;
begin
  result := pInteger(Ptr)^;
end;
 
procedure TClass32Int.SetInt(value: integer);
begin
  pInteger(Ptr)^ := value;
end;
 
{ TClass32Float }
 
constructor TClass32Float.Create;
begin
  // invoque un TClass32
  inherited;
  // l'initialise à 0
  SetFloat(0.0);
end;
 
function TClass32Float.GetFloat: single;
begin
  result := pSingle(Ptr)^;
end;
 
procedure TClass32Float.SetFloat(value: single);
begin
  pSingle(Ptr)^ := value;
end;
 
{ TClass64Int }
 
constructor TClass64Int.Create;
begin
  // invoque un TClass64
  inherited;
  // et initialise à 0
  Setint(0);
end;
 
function TClass64Int.GetInt: int64;
begin
  result := pInt64(Ptr)^;
end;
 
procedure TClass64Int.SetInt(value: int64);
begin
  pInt64(Ptr)^ := value;
end;
 
{ TClass64Float }
 
constructor TClass64Float.Create;
begin
  // invoque un TClass64
  inherited;
  // et initialise à 0
  SetFloat(0.0);
end;
 
function TClass64Float.GetFloat: double;
begin
  result := pDouble(Ptr)^;
end;
 
procedure TClass64Float.SetFloat(value: double);
begin
  pDouble(Ptr)^ := value;
end;

et avec les génériques c'est encore plus simple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
type
  TClassBase<T> = class
  private
    fValue: T;
  public
    property Value: T read fValue write fValue;
  end;
 
  TClass32Int   = TClassBase<Integer>;
  TClass32Float = TClassBase<Single>;
  TClass64Int   = TClassBase<Int64>;
  TClass64Float = TClassBase<Double>;

[Jcpan]

en respectant les init et final des classes ancêtre, ce qui evite de réécrire tout le code du début à la fin.

init et final à partir de quel version ?

[Dr.Who]

initialisation et finalisation d'un objet.
à ce stade, tu n'as pas à t'en soucier.

mais, admettons une classe A, qui créer et detruit un bloc memoire de X octets.
puis une classe B, dérivée de A, mais qui "ecrase" le destructeur de A. donc, B ne pourra plus liberer le bloc memoire.
Admettons l'inverse, que B ecrase le constructeur de A mais pas son destructeur, le bloc memoire ne sera plus créer donc nous pourrons avoir des erreur, puis a la destruction B tentera de detruire un bloc memoire n'existant pas, encore une erreur.

il est donc important de toujours bien respecter quand on derive une classe.
bien sur, tout cela peut se faire depuis Delphi 2 à 2010 à plus ou moins de difference prés.

[Andnotor]

Rien n'empêche une méthode de B d'appeler une méthode de A par un inherited même si elle n'est pas override.

Virtual/override est la mise en route d'une des notions fondamentales de la POO: le polymorphisme. Soit, la déclaration d'une variable d'un type (plus ou moins) générique et son affectation réelle par une classe dérivée (mais qui a par conséquent les mêmes caractéristiques de mise en œuvre).

[Dr.Who]

tout a fait, si B ecrase une methode de A, par exemple une fonction qui renvois un chiffre, en appelant inherited A.Methode dans B.Methode on pourra récuperer la valeur A.Methode même si elle n'est pas virtuelle, dynamique dans A ou surchargée dans B, a condition d'être au minimum Protected dans A.
Si private et hors unité, impossible d'y accéder sans une astuce de gnou.