Comment déclaration de type function of object

Version imprimable

Bonjour à tous

Je souhaite standardiser à priori l'appel pour une série de fonctions... Mais ça ne marche pas... J'ai des erreurs, j'ai déjà réussi à le faire mais j'ai oublié comment...

Façon 1:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
type fFunctionMAJ:function (Symbole:string):boolean of object;

Mon_Objet=class
    function MAJ:fFunctionMAJ;
end;

implementation

var Functions_MAJ:array[0..1] of fFunctionMAJ;

function Mon_Objet.MAJ:fFunctionMAJ;
begin
    result:=false;//[dcc32 Erreur] Unit1.pas(3013): E2010 Types incompatibles : 'fFonction_MAJ' et 'Boolean'
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
    aFunction_MAJ[0]:=Mon_Objet.Maj;//[dcc32 Erreur] Unit1.pas(3618): E2010 Types incompatibles : 'Boolean' et 'fFonction_MAJ'
end;

Façon 2:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
type fFunctionMAJ:function (Symbole:string):boolean of object;

Mon_Objet=class
    function MAJ(Symbole:string):boolean ;
end;

implementation

var Functions_MAJ:array[0..1] of fFunctionMAJ;

function Mon_Objet.MAJ(Symbole:string):boolean;
begin
    result:=false;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin                                          
    aFunction_MAJ[0]:=Mon_Objet.Maj;// [dcc32 Erreur] Unit1.pas(3618): E2010 Types incompatibles : 'fFonction_MAJ' et 'Procedure'
end;

Merci d'avance pour votre aide

Bonjour,
Effectivement il y a quelques erreurs dans ton code.

l'Ajout des mots "of object" au nom défini un type pointeurs de méthode, c'est-à-dire un pointeur sur l'adresse de la procédure. cette spécification permet de pointer cette méthode dans une instance de l'objet dans laquelle cette méthode est décrite :

Pour exemple - Extrait du contenu de System.Messaging :
Code:

1 2 3 4 5 6 7 8 unit System.Messaging; ... TMessageListenerMethod = procedure(const Sender: TObject; const M: TMessage) of object; ... function TMessageManager.SubscribeToMessage(const AMessageClass: TClass; const AListenerMethod: TMessageListenerMethod): Integer; ...
En fonction de ce que tu veux faire je peux te donner des exemples

Bonjour et merci

En bref, ce que je fais maintenant c'est :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
var ObjetSelectionne:integer;
 
procedure TForm1.Timer1Timer(Sender: TObject);
var resultat:boolean;
begin
     case ObjetSelectionne of
       0:resultat:=MonObjet0.MAJ0;
       1:resultat:=MonObjet1.MAJ1;
       ...
       n:resultat:=MonObjetN.MAJ1;
    end;
    if resultat then ...
end;

À toutes les fois que je programme un nouvel MonObjetN je dois rajouter une ligne dans chaque "case" où une telle sélection doit se faire.

À la place je souhaiterais faire ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var ObjetSelectionne:integer;
    MAJs:array[0..N] of function () of object;
procedure TForm1.FormCreate(Sender: TObject);
begin
     setlength(MAJs,ObjetsTotaux);
//Initialisa
     MAJs[0]:=MonObjet0.MAJ;
     MAJs[1]:=MonObjet1.MAJ;
     ...
     MAJs[N]:=MonObjet1.MAJ;
end;
 
procedure TForm1.Timer1Timer(Sender: TObject);
begin
     if MAJs[ObjetSelectionne] then ...//Majs
end;

Le problème que j'ai, émane de ceci:

Code:

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
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls;
 
type
MonObjetGenerique=class
public
ObjetType:integer;
    constructor create;
    function QuiSuisJe:integer;
end;
 
MonObjet0=Class(MonObjetGenerique)
public
ObjetType:integer;
     constructor create;
     function QuiSuisJe:integer;
end;
 
MonObjet1=Class(MonObjetGenerique)
public
ObjetType:integer;
     constructor create;
     function QuiSuisJe:integer;
end;
 
 
  TForm1 = class(TForm)
    Timer1: TTimer;
    procedure FormCreate(Sender: TObject);
 
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
 
implementation
 
{$R *.dfm}
 
Var Objet0:MonObjetGenerique;
    Objet1:MonObjetGenerique;
 
constructor MonObjetGenerique.create;
begin
    ObjetType:=-1;
end;
 
constructor MonObjet0.create;
begin
    inherited create;
    ObjetType:=0;
end;
 
constructor MonObjet1.create;
begin
    inherited create;
    ObjetType:=1;
end;
 
function MonObjetGenerique.QuiSuisJe:integer;
begin
    result:=-1;
end;
 
function MonObjet0.QuiSuisJe:integer;
begin
 
    result:=0;
end;
 
function MonObjet1.QuiSuisJe:integer;
begin
    result:=1;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
     Objet0:=MonObjet0.create;
     Objet1:=MonObjet1.create;
 
    form1.Caption:='ObjetType: '+inttostr(Objet0.ObjetType)+', Qui-suis-je: '+inttostr(Objet0.QuiSuisJe)+' '
                  +'ObjetType: '+inttostr(Objet1.ObjetType)+', Qui-suis-je: '+inttostr(Objet1.QuiSuisJe);
 
end;
 
end.

L'incapacité du composant de savoir de quel essence est sa création, car elle est inconnue et variable dépendamment de la volonté de l'utilisateur final. Il revient systématiquement à son ancêtre.

En solution, à toutes les fois que la fonction MAJ est appelé, l'ancêtre regarde quel composant a été choisi et sélectionne le bon descendant.

Le pourquoi que je souhaite remplacer le case par un appel de fonction via un tableau, c'est pour la maintenance. C'est plus simple de copier-coller des lignes de code dans le create et modifier l'indice que d'ajouter ça et là dans tous les cases une ligne spécifiant la routine du bon composant.

M.A.J. : En utilisant un variant est-ce que pourrais résoudre le problème d'ignorance sur la nature même du composant?

Bonjour,

voici un petit exemple basé sur ton code :

Code:

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
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;
 
type
 
  TMAJFunc = function: Integer of object;
 
  TMAJFuncArray = array of TMAJFunc;
 
  TMonObjetGenerique = class(TObject)
  private
    FObjetType: integer;
  public
    constructor create;
    function QuiSuisJe: integer; virtual;
    property ObjetType: integer read FObjetType write FObjetType;
  end;
 
  TMonObjet0 = class(TMonObjetGenerique)
  public
    constructor create; overload;
    function QuiSuisJe: integer; override;
  end;
 
  TMonObjet1 = class(TMonObjetGenerique)
  public
    constructor create; overload;
    function QuiSuisJe: integer; override;
  end;
 
 
  TForm1 = class(TForm)
    Label1: TLabel;
    Label2: TLabel;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
 
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1        : TForm1;
 
 
implementation
 
{$R *.dfm}
 
var
  Objet        : TMonObjetGenerique;
  Objet0       : TMonObjetGenerique;
  Objet1       : TMonObjetGenerique;
  MAJFuncArray : TMAJFuncArray;
 
constructor TMonObjetGenerique.create;
begin
  FObjetType := -1;
end;
 
constructor TMonObjet0.create;
begin
  inherited create;
  FObjetType := 0;
end;
 
constructor TMonObjet1.create;
begin
  inherited create;
  FObjetType := 1;
end;
 
function TMonObjetGenerique.QuiSuisJe: integer;
begin
  result := FObjetType;
end;
 
function TMonObjet0.QuiSuisJe: integer;
begin
 
  result := FObjetType;
end;
 
function TMonObjet1.QuiSuisJe: integer;
begin
  result := FObjetType;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  Objet := TMonObjetGenerique.create;
  Objet0 := TMonObjet0.create;
  Objet1 := TMonObjet1.create;
 
  Label1.Caption := 'Objet ClassName: ' + Objet.ClassName + #9 + ' ObjetType: ' +
    inttostr(Objet.ObjetType) + ', Qui-suis-je: ' + inttostr(Objet.QuiSuisJe) + #13 +
    'Objet ClassName: ' + Objet0.ClassName + #9#9 + ' ObjetType: ' + inttostr(Objet0.ObjetType) +
    ', Qui-suis-je: ' + inttostr(Objet0.QuiSuisJe) + #13 +
    'Objet ClassName: ' + Objet1.ClassName + #9#9 + ' ObjetType: ' + inttostr(Objet1.ObjetType) +
    ', Qui-suis-je: ' + inttostr(Objet1.QuiSuisJe);
 
 
  SetLength(MAJFuncArray, 3);
  MAJFuncArray[0] := Objet.QuiSuisJe;
  MAJFuncArray[1] := Objet0.QuiSuisJe;
  MAJFuncArray[2] := Objet1.QuiSuisJe;
 
  Label2.Caption := 'ObjetType: ' + inttostr(MAJFuncArray[0]) + ', Qui-suis-je: ' +
    inttostr(MAJFuncArray[0]) + ' '
    + 'ObjetType: ' + inttostr(MAJFuncArray[1]) + ', Qui-suis-je: ' + inttostr(MAJFuncArray[1]) + ' '
    + 'ObjetType: ' + inttostr(MAJFuncArray[2]) + ', Qui-suis-je: ' + inttostr(MAJFuncArray[2]);
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
  Objet.Free;
  Objet0.Free;
  Objet1.Free;
end;
 
end.

Cordialement,

@+

MAJ: retrait du code inutile :oops:

Objet polymorphe

Voici un petit exemple implémentatnt le plymorphisme;
Tu dois avoir une classe ancêtre au départ avec une méthode "Virtual".
Ceci est un ememple dans un programme "Console" ce qui explique la présence de Writeln et Readln

Code:

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
 
. . .
  TVelo = class
    position: integer;
    procedure avancer; virtual ;
  end;
 
  TVeloMoteur = class(TVelo)
    Reservoir : integer ;
    procedure avancer; override ;
  end;
 
procedure TVelo.avancer;
begin
  position := position + 1;
end;
 
procedure TVeloMoteur.avancer;
begin
  position := position + 10 ;
  reservoir := reservoir - 1 ;
end;
 
var
  mesDeuxRoues  : array [0..1] of TVelo;
  i1 : Integer;
begin
  mesDeuxRoues[0] := TVelo.Create ;
  mesDeuxRoues[0].position := 0 ;
  mesDeuxRoues[1] := TVeloMoteur.Create ;
  mesDeuxRoues[1].position := 0 ;
  for i1 := low(mesDeuxRoues) to high(mesDeuxRoues) do
  begin
    mesDeuxRoues[i1].avancer;
    writeln(mesDeuxRoues[i1].ClassName + '=' +
      intToStr(mesDeuxRoues[i1].position))
  end;
  for i1 := low(mesDeuxRoues) to high(mesDeuxRoues) do
    mesDeuxRoues[i1].free;
  readln;
end.

Citation:

Envoyé par Cirec

Bonjour,

voici un petit exemple basé sur ton code :

Code:

...

Cordialement,

@+

MAJ: retrait du code inutile :oops:

Merci pour le cours de programmation... :oops:

Du coup le code devient

Code:

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
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls;
 
type
MonObjetGenerique=class
public
ObjetType:integer;
    constructor create;
    function QuiSuisJe:integer;
end;
 
MonObjet0=Class(MonObjetGenerique)
public
ObjetType:integer;
     constructor create;
     function QuiSuisJe:integer;
end;
 
MonObjet1=Class(MonObjetGenerique)
public
ObjetType:integer;
     constructor create;
     function QuiSuisJe:integer;
end;
 
 
  TForm1 = class(TForm)
    Timer1: TTimer;
    procedure FormCreate(Sender: TObject);
 
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
 
implementation
 
{$R *.dfm}
 
Var Objet0:MonObjetGenerique;
    Objet1:MonObjetGenerique;
 
constructor MonObjetGenerique.create;
begin
    ObjetType:=-1;
end;
 
constructor MonObjet0.create;
begin
    inherited create;
    ObjetType:=0;
end;
 
constructor MonObjet1.create;
begin
    inherited create;
    ObjetType:=1;
end;
 
function MonObjetGenerique.QuiSuisJe:integer;
begin
    result:=-1;
end;
 
function MonObjet0.QuiSuisJe:integer;
begin
 
    result:=0;
end;
 
function MonObjet1.QuiSuisJe:integer;
begin
    result:=1;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
     Objet0:=MonObjet0.create;
     Objet1:=MonObjet1.create;
 
    form1.Caption:='ObjetType: '+inttostr(Objet0.ObjetType)+', Qui-suis-je: '+inttostr(Objet0.QuiSuisJe)+' '
                  +'ObjetType: '+inttostr(Objet1.ObjetType)+', Qui-suis-je: '+inttostr(Objet1.QuiSuisJe);
 
end;
 
end.

Du coup je n'ai plus besoin du tableau de fonction

Merci encore et désolé

Citation:

Envoyé par sgmsg

Merci pour le cours de programmation... :oops:

Du coup le code devient

Code:

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
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls;
 
type
MonObjetGenerique=class
public
ObjetType:integer;
    constructor create;
    function QuiSuisJe:integer;
end;
 
MonObjet0=Class(MonObjetGenerique)
public
ObjetType:integer;
     constructor create;
     function QuiSuisJe:integer;
end;
 
MonObjet1=Class(MonObjetGenerique)
public
ObjetType:integer;
     constructor create;
     function QuiSuisJe:integer;
end;
 
 
  TForm1 = class(TForm)
    Timer1: TTimer;
    procedure FormCreate(Sender: TObject);
 
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
 
implementation
 
{$R *.dfm}
 
Var Objet0:MonObjetGenerique;
    Objet1:MonObjetGenerique;
 
constructor MonObjetGenerique.create;
begin
    ObjetType:=-1;
end;
 
constructor MonObjet0.create;
begin
    inherited create;
    ObjetType:=0;
end;
 
constructor MonObjet1.create;
begin
    inherited create;
    ObjetType:=1;
end;
 
function MonObjetGenerique.QuiSuisJe:integer;
begin
    result:=-1;
end;
 
function MonObjet0.QuiSuisJe:integer;
begin
 
    result:=0;
end;
 
function MonObjet1.QuiSuisJe:integer;
begin
    result:=1;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
     Objet0:=MonObjet0.create;
     Objet1:=MonObjet1.create;
 
    form1.Caption:='ObjetType: '+inttostr(Objet0.ObjetType)+', Qui-suis-je: '+inttostr(Objet0.QuiSuisJe)+' '
                  +'ObjetType: '+inttostr(Objet1.ObjetType)+', Qui-suis-je: '+inttostr(Objet1.QuiSuisJe);
 
end;
 
end.

Du coup je n'ai plus besoin du tableau de fonction

Merci encore et désolé

si tu fais ça ça ne fonctionnera pas le résultat sera -1 à chaque fois !!!
tu as retiré toute notion d'héritage ... compare avec le code que j'ai donné. ;)

Cordialement,
@+

Il va falloir revoir les bases de la POO.

Code:

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
interface
 
type
  TMonObjetGenerique = class
  private
    ObjetType :integer;
  public
    constructor create; virtual; abstract;
    function    QuiSuisJe: integer;
  end;
 
  TMonObjet0 = class(TMonObjetGenerique)
  public
    constructor create; override;
  end;
 
  TMonObjet1 = class(TMonObjetGenerique)
  public
    constructor create; override;
  end;
 
implementation
 
{ TMonObjetGenerique }
 
function TMonObjetGenerique.QuiSuisJe: integer;
begin
  Result := ObjetType;
end;
 
{ TMonObjet0 }
 
constructor TMonObjet0.create;
begin
  inherited;
  ObjetType := 0;
end;
 
{ TMonObjet1 }
 
constructor TMonObjet1.create;
begin
  inherited;
  ObjetType := 1;
end;

05/08/2018, 19h12
Cirec

@Andnotor,

d'après ce que j'ai compris il voulait une implémentation différente de "QuiSuisJe" en fonction de l'objet choisi
et ObjetType n'est pas initialisée pour l'ancêtre de base en procédant ainsi mais il n'en a peut être pas besoin.

Cordialement,
@+

Désolé Cirec, je n'ai pas fait le bon copier-coller dans le bloc de code:

Code:

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
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls;
 
type
MonObjetGenerique=class
public
ObjetType:integer;
    constructor create;
    function QuiSuisJe:integer;virtual;
end;
 
MonObjet0=Class(MonObjetGenerique)
public
     constructor create;
     function QuiSuisJe:integer; override;
end;
 
MonObjet1=Class(MonObjetGenerique)
public
     constructor create;
     function QuiSuisJe:integer; override;
end;
 
 
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
 
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
 
implementation
 
{$R *.dfm}
 
Var Objet0:MonObjetGenerique;
    Objet1:MonObjetGenerique;
 
constructor MonObjetGenerique.create;
begin
    ObjetType:=-1;
end;
 
constructor MonObjet0.create;
begin
    inherited create;
    ObjetType:=0;
end;
 
constructor MonObjet1.create;
begin
    inherited create;
    ObjetType:=1;
end;
 
function MonObjetGenerique.QuiSuisJe:integer;
begin
 
    result:=-1;
end;
 
function MonObjet0.QuiSuisJe:integer;
begin
    result:=inherited quisuisje;
    result:=0;
end;
 
function MonObjet1.QuiSuisJe:integer;
begin
    result:=inherited quisuisje;
    result:=1;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
     Objet0:=MonObjet0.create;
     Objet1:=MonObjet1.create;
 
    form1.Caption:='ObjetType: '+inttostr(Objet0.ObjetType)+', Qui-suis-je: '+inttostr(Objet0.QuiSuisJe)+' '
                  +'ObjetType: '+inttostr(Objet1.ObjetType)+', Qui-suis-je: '+inttostr(Objet1.QuiSuisJe);
 
end;
 
end.

Merci à tous

...

En recherchant un peu, le code, que j'implémentais, était une façon de rendre virtuel les procédures qui étaient déclarées static (par défault)