Problème avec TParser10

Version imprimable

Bonjour à toutes et à tous,

A ceux qui connaissent l'éditeur/résolveur d'équation à l'exécution : TParser http://delphi.icm.edu.pl/ftp/d10free/parser10.zip

Je souhaite utiliser une des fonctions avancées de ce Parser qui est le traitement d'une fonction prédéfinie via l'instruction : AddFunctionOneParam ou AddFunctionTwoParam.

Sous Delphi6, j'ai le code suivant qui se compile :
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 unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, Parser10, StdCtrls; type TUneFonction = procedure (Ope: POperation) of object; TForm1 = class(TForm) Button1: TButton; Parser1: TParser; Edit1: TEdit; procedure Button1Click(Sender: TObject); private { Déclarations privées } MonOpe: TOperation; UneFonction: TUneFonction; procedure MaFonction(Ope: POperation); public { Déclarations publiques } end; var Form1: TForm1; implementation {$R *.dfm} procedure TForm1.MaFonction(Ope: POperation); begin with Ope^ do begin Dest^:= Sin(Arg1^)*Cos(Arg2^); end; end; procedure TForm1.Button1Click(Sender: TObject); begin UneFonction:= MaFonction; {PB1} Parser1.AddFunctionTwoParam('MaFonction', @UneFonction); {PB2} Parser1.Expression:= 'MaFonction'; Edit1.Text:= FloatToStr(Parser1.Value); end; end.
Cela ne se compile pas sous Lazarus. A la ligne marqué PB1 il faut que je remplace ""MaFonction" par "@MaFonction". Mais alors, le problème se reporte à la ligne suivante et que j'enlève ou laisse l"@" deant "UneFonction", ça bug toujours.

Je tourne en rond et ne sais plus quoi faire.

Merci de votre aide.

Pierre

pointeur de fonction attendus et tu envois un pointeur de méthode.
logique que ça ne passe pas.

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
 
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Parser10, StdCtrls;
 
type
  TFunction = procedure(aOperation: POperation);
 
  TForm1 = class(TForm)
    Button1: TButton;
    Parser1: TParser;
    Edit1: TEdit;
    procedure Button1Click(Sender: TObject);
  private
    fOperation : TOperation;
  public
 
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
uses Math;
 
procedure MyFunction(aOperation: POperation);
begin
  aOperation^.Dest^ := Sin(aOperation^.Arg1^)*Cos(aOperation^.Arg2^);
end;
 
procedure TForm1.Button1Click(Sender: TObject);
begin
 
  Parser1.AddFunctionTwoParam('MyFunction', @MyFunction); 
  Parser1.Expression := 'MyFunction';
 
  Edit1.Text := FloatToStr(Parser1.Value);
end;
 
end.

15/01/2010, 15h32
ChPr

Oui, merci Dr Who, de me le rappeler, c'est mon erreur (ce n'est pas la première fois que cela m'arrive). Faut que je me burine ça dans la tête.

Cordialement.

Pierre

bah alors! :mouarf:

t'inquiète pas, ça arrive même aux meilleurs d'entre nous.
et comme les cas de passage de fonctions en arguments sont assé rare ou trop peu souvent mis en pratique ... ceci explique cela.

à partir de D2007 et probablement D2006 on peux faire 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
program Project16;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils, Classes, Windows;
 
type
  // simple function
  TFunction    = function(A, B: integer): integer;
 
  // only with D2009+
  TRefFunction = reference to function(A, B: integer): integer;
 
  TMaClasse = class
  public
    // only with D2007+
    class function F(A,B: integer): integer; static;
  end;
 
 
class function TMaClasse.F(A, B: integer): integer;
begin
  result := A + B;
end;
 
// simple function
function XF(A, B: integer): integer;
begin
  result := A * B;
end;
 
 
// caller for "reference to" functions
procedure RefCallCalcAB(aFunction: TRefFunction; const A, B: integer);
begin
  writeln(aFunction(A, B));
end;
 
// caller for simple function 
procedure CallCalcAB(aFunction: TFunction; const A, B: integer);
begin
  Writeln(aFunction(A, B));
end;
 
var
  Cl : TMaClasse;
begin
  // can call all functions
  RefCallCalcAB(XF, 10, 20); // 200
 
  // can call only simple function 
  CallCalcAB(XF, 10, 20); // 200
 
  Cl := TMaClasse.Create;
  try
    RefCallCalcAB(CL.F, 10, 20); // 30
 
    // Compiling ok if CL.F is class function static.
    CallCalcAB(CL.F, 10, 20); // 30
 
    ReadLn;
  finally
    Cl.Free;
  end;
end.