Appel d'une fonction/TThread de façon paramétrique

**noahsaga** · 31/03/2011, 23h16

Salut à tous,

Je cherche à créer dans un .cpp 70 fonctions nommées F_1(..) à F_70(..) ou 70 Tthread, c'est selon vos conseils. chacune de ces 70 fonctions feront qqchose de différent, les variables seront différentes en type et en nombre.

Ces fonctions créées je voudrais pouvoir les appelées en fonction de l'état d'un int d'une boucle pas forcément linéaire. Cad si :

i = 23 , j'appelle la fonction F_23(..) et je passe les paramètres qui vont bien et qui ne sont pas forcément en nombre constant entre les fonctions.

Bien évidemment le switch / case est possible mais ce n'est pas très élégants et pas top en ce qui concerne le caractère évolutif.

**ShaiLeTroll** · 01/04/2011, 09h32

Nommer des fonctions de 1 à 70 !
C'est une mauvais idée surtout si les fonctions ont des paramètres variables et des taches tout aussi variable !

70 Threads, ce n'est pas mieux, surtout si simultané, dépassé 16 threads pour un même process, ce n'est pas terrible, j'ai déjà vu avec D5+FastMM des applis avec 1800 threads, l'OS passe son temps à distribuer du temps, mieux vaut utiliser un répartiteur de tache !
Après mes remarques date de D6 sur Win2K, peut-être qu'avec des BSD plus récents, des OS server plus récents, multi-proc... c'est peut-être une pratique mieux toléré !

Si tu avais toujours le même contexte d'execution, pourquoi pas !
J'espère que ton code sera bien documenté pour indiquer ce que fait les fonctions, une énumération de 1 à 70 (0 étant l'absence d'opération) serait déjà plus propre !

Tu pourrais utiliser un objet, toujours le même, et avec les RTTI tu définis son contenu, il te faut un fichier XML, DFM ou INI, qui décrit les paramètres de chacune des fonctions, ainsi la fonction d'appel reste générique, et les fonctions appelés savent ce qu'elles doivent lire dans cet objet de contexte !

Tu devrais regarder comment implementer une Machine à état finie, normalement d'un point tu ne passe qu'à un nombre limité de point, ça permet de mieux vérouiller ton algo !
Ci n'est pas le cas, je me demande bien quel est ton projet pour devoir faire une tel uzinagaz !

**noahsaga** · 04/04/2011, 11h16

ok commençons par le début.

Nous travaillons sur un banc de test. Pour tester les organes les opérateurs créent des fiches de tests composées de plusieurs "fonctions" : remplissage du réservoir, montée en pression, mesure du temps de vidange, test électrique, test de l'asservissement...

Chaque organe à tester suit un ordre différent de ces fonctions.

Par exemple, pour l'organe A :

1. fonction 1 : test électrique
2. fonction 3 : remplissage du réservoir
3. fonction 5 : activation de la vanne H et mesure de la pression
4. fonction 10 : Activation de l'asservissement et mesure du temps de montée à 90% (d'où le thread chronomètre...)
...

pour l'organe B :

1. fonction 3 : remplissage du réservoir
2. fonction 5 : activation de la vanne H et mesure de la pression
3. fonction 1 : test électrique
4. fonction 9 : mesure de la pression du reniflard
...

La fiche d'essai est gérée par BDD, cette partie est maitrisée. La BDD fournie au prog principal l'enchainement des fonctions sous forme d'un fichier ".ini" :

...
[11] ordre d'execution de la fonction
id=31 identifiant de la fonction
nom=Monté en pression circuit ACC info
description=vérification du temps de la montée en pression du circuit S info
conditions=AIP_44_1;timer liste des paramètres
AIP_44_1=150 valeur du paramètre 1
timer=70 valeur du paramètre 2
variables=t_acc_1 liste des variables résultat
t_acc_1=0 valeur de la variable 1
...

et cela pour toutes les fonctions.

Je veux donc coder dans le prog principal chaque fonction de 1 à 70 (ou plus) qui seront uniques. Je n'ai pas le choix, il faut le faire en dur...
A la réception du fichier ".ini" le prog principale déroule un genre de Graphcet de fonctions. Il appelle successivement chaque fonction du fichier ".ini".
Chaque fonction recevra en paramètre l'ordre d'exécution qui leur permet d'aller chercher dans le fichier ini les valeurs des paramètres et le nom des variables résultats.
Dès qu'une fonction est finie, j'appelle la suivante et ainsi de suite.

Il n'y aura donc jamais plusieurs fonctions en même temps! Mais j'avais déjà abandonné l'idée des thread trop contraignante pour le transfert d'info.

La partie du code qui nous intéresse dans le sujet de la discussion et donc de savoir comment, dans une boucle "for" sur un entier i, appeler les 70 fonctions en lien avec la valeur de i dans utiliser un switch / case de 70 de long.

Pour revenir à notre bout de fiche d'essai : si i = 11, j'appelle la fonction 31 avec comme paramètre 11.

**ShaiLeTroll** · 04/04/2011, 14h14

Regarde TObject.MethodAddress ou TypInfo.GetMethodProp

**noahsaga** · 04/04/2011, 17h38

ok je regarde un peu et j'ai trouvé ça qui pourrait coller mais c'est en delphi:

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
unit MethodAddress1;
 
(*
 
  This sample shows how to call a funciton by name. We use MethodAddress to
  retrive the name of a function, then we call it.
 
  Since the method belongs to a class, we need to pass the class as a prameter,
  too.
 
  In gerneral, a function - declared in a class, that is defined as
     procedure TFoo.foo(i : integer);
  is called as
     procedure TFoo.foo(obj : TObject; i : integer);
 
  Normally, Delphi (as well as C++) automatically add the object parameter. Now
  that we get a pointer to a function from MethodAddress, that does not belong to
  any class, we need to pass the parameter by hand
 
  (C) Thomas Quester
      tquester@joice.net
      http://arabella.joice.net
 
*)
 
 
interface
 
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls;
 
type
 
  TTest = class
  public
    Calls : integer;
  published
    Procedure Foo;
    Procedure Test;
    Procedure Bar;
    procedure TestI(i : integer);
    procedure TestS(s : string);
    function  Fak(i : integer) : integer;
  end;
 
  // For every combination of parameters, we define a prototype
 
  TFunctionCall = procedure(obj : TObject);
  TFunctionICall = procedure(obj : TObject; i : integer);
  TFunctionSCall = procedure(obj : TObject; s : string);
  TFunctionIICall = function (obj : TObject; i : integer) : integer;
 
 
  TForm1 = class(TForm)
    Label1: TLabel;
    ComboBox1: TComboBox;
    Button1: TButton;
    Label2: TLabel;
    Label3: TLabel;
    EditPar: TEdit;
    EditResult: TEdit;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
      FTest:TTest;
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.DFM}
 
 
procedure TForm1.Button1Click(Sender: TObject);
var p     : pointer;
    ptr   : TFunctionCall;              // Without parametes
    ptrI  : TFunctionICall;            // (i : integer);
    ptrS  : TFunctionSCall;            // (s : string);
    ptrII : TFunctionIICall;           // (i : integer) : integer
    s     : string;
 
begin
  s := combobox1.text;
  p := FTest.MethodAddress(s);            // Get the pointer
  if p <> NIL then begin
     ptr := p;                            // Assign it to every protorype
     ptri := p;
     ptrii := p;
     ptrs := p;
     s := Lowercase(s);                  // Now, we decide, what prototype to use.
 
     if  (s = 'foo') or (s = 'bar') or (s = 'test')
                        then ptr(FTest);
     if  (s = 'testi')  then ptri(FTest,strtoint(editPar.text));
     if  (s = 'tests')  then ptrs(Ftest,EditPar.text);
     if  (s = 'fak')    then editResult.text := inttostr(ptrii(ftest,strtoint(editPar.text)));
  end else
     MessageBox(0,'Function not defined','',MB_OK);
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  FTest := TTest.Create;
  FTest.Calls := 0;
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
  FTest.Free;
end;
 
 
 
// ------------------------------------------------------------------------
// procedure TTest Foo
// Created : Quester 09.06.99 11:04:57
// ------------------------------------------------------------------------
 
 
Procedure TTest.Foo;
begin
  messagebox(0,'foo',pchar(format('%d calls',[calls])),MB_OK);
  inc(calls);
end;
 
 
// ------------------------------------------------------------------------
// procedure TTest Bar
// Created : Quester 09.06.99 11:05:08
// ------------------------------------------------------------------------
 
 
Procedure TTest.Bar;
begin
  messagebox(0,'Bar',pchar(format('%d calls',[calls])),MB_OK);
  inc(calls);
end;
 
procedure TTest.TestI(i : integer);
begin
  messagebox(0,pchar(format('i = %d',[i])),pchar(format('%d calls',[calls])),MB_OK);
  inc(calls);
end;
 
procedure TTest.TestS(s : string);
begin
  messagebox(0,pchar(format('s = %s',[s])),pchar(format('%d calls',[calls])),MB_OK);
  inc(calls);
 
end;
function  TTest.Fak(i : integer) : integer;
var j : integer;
begin
   result := 1;
   for j := 1 to i do
     result := result * j;
end;
 
 
// ------------------------------------------------------------------------
// procedure TTest Test
// Created : Quester 09.06.99 11:05:15
// ------------------------------------------------------------------------
 
 
Procedure TTest.Test;
begin
  messagebox(0,'Test ',pchar(format('%d calls',[calls])),MB_OK);
  inc(calls);  
end;
 
 
 
end.

j'ai déjà un problème avec la traduction de ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
procedure TForm1.Button1Click(Sender: TObject);
var p     : pointer;
    ptr   : TFunctionCall;              // Without parametes
    ptrI  : TFunctionICall;            // (i : integer);
    ptrS  : TFunctionSCall;            // (s : string);
    ptrII : TFunctionIICall;           // (i : integer) : integer
    s     : string;
 
begin
...

Quelle est la syntaxe en C++ pour ces déclarations
qu'est ce que c'est que cette classe pointer :

Code :

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

var p     : pointer;

après je dois merder dans ma syntaxe car mon bout de prog ne compile pas, il me dit que published est réservé pour les objets VCL...

**ShaiLeTroll** · 05/04/2011, 10h18

En même temps, trouver du Delphi pour C++Builder, c'est assez logique !

Tu as un problème avec la traduction, tu pourrais fournir le travail que tu as déjà commencé que l'on puisse t'aider à le corriger

Code :

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

typedef int __fastcall (*TFunctionIICall)(int i);

il y a des mots clés comme __closure pour modifier la déclaration, il faudrait vérifier cela !

pointer = void*

Je suis aussi novice en C++, je connais bien Delphi et donc la VCL, mais la syntaxe C++ me semble assez indigeste !

**noahsaga** · 05/04/2011, 12h05

salut,

Déjà merci pour ta réponse qui m'a fait progresser.

Reste semble-t-il un petit problème car je n'arrive pas à assigner le pointer p à la fonction d'appel : Cannot convert 'void*' to 'void(*)(Tobject *, int*)

voici mon code pour tester ces appels :

le .h de la form contenant la class et la fonction d'appel:

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
 
class f_centrale : public TObject
{
private:
 
public:
        void F_1(int Index);
        void F_2(int Index);
        void F_3(int Index);
        void F_4(int Index);
        void F_5(int Index);
        void F_6(int Index);
        void F_7(int Index);
        void F_8(int Index);
        void F_9(int Index);
        void F_10(int Index);
        void F_11(int Index);
 
};
 
typedef void TFonc_Call(TObject *Object, int Index);

le .cpp de la form dans lequel est le code des fonction de la classe, très basique, c'est du debbuggage :

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
//F1
void f_centrale::F_1(int Index)
{
  ShowMessage("F1");
}
 
//F2
void f_centrale::F_2(int Index)
{
  ShowMessage("F2");
}
 
//F3
void f_centrale::F_3(int Index)
{
  ShowMessage("F3");
}
 
...
 
//F11
void f_centrale::F_11(int Index)
{
  ShowMessage("F11");
}

le code pour appeler la fonction, le numéro de la fonction est choisi par la valeur de position d'un UpDown :

le .h :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public:
...
        ThChrono *chrono[10];
 
        AnsiString nom_fonc; //nom de la fonction à appeler
        f_centrale *FFonc;
};
//---------------------------------------------------------------------------
extern PACKAGE Tecran_essai *ecran_essai;

le .cpp :

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
void __fastcall Tecran_essai::UpDown1Click(TObject *Sender,
      TUDBtnType Button)
{
  TFonc_Call *ptfonc;
  void *p;
  int i = UpDown1->Position;
 
  cltree->NodeActif = i;
  nom_fonc = "F_" + IntToStr(i); //création de la chaine contenant
                                                 // le nom de la fonction
 
  p = FFonc->MethodAddress(nom_fonc);
 
  if (p != NULL)
  {
    ptfonc = p;
    ptfonc(FFonc, i);
  }
  else ShowMessage("fonction non trouvée");
}
//---------------------------------------------------------------------------

**noahsaga** · 05/04/2011, 14h30

Bon ça progresse. En modifiant le .h comme ceci :

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
class f_centrale : public TObject
{
private:
 
public:
        __fastcall f_centrale(TComponent* Owner);
 
        AnsiString chemin;
 
__published:
        void F_1(int Index);
        void F_2(int Index);
        void F_3(int Index);
        void F_4(int Index);
        void F_5(int Index);
        void F_6(int Index);
        void F_7(int Index);
        void F_8(int Index);
        void F_9(int Index);
        void F_10(int Index);
        void F_11(int Index);
 
};

Je vois au debbugger que p trouve la fonction et pointe dessus. Le caractère

Code :

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

__published:

est véritablement obligatoire.

Par contre, je ne vois vraiment pas comment faire pointer ptfonc sur p...

**ShaiLeTroll** · 05/04/2011, 16h16

tu devrais essayer sur f_centrale de changer le type de tes fonctions, cela m'étonne que le __fastcall ne soit pas pas réclamer par __published !

faut ajouter __fastcall dans HPP et CPP de f_centrale

Code :

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

1
2
3
4
5
 
void __fastcall f_centrale ::F_1(int Index)
{
  ShowMessage("F1 " + IntToStr(Index));
}

Tu as la version basique, mais étant delphiste, ça me choque d'appeler une méthode comme une procédure car this sera invalide !

Code :

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

typedef void __fastcall (__closure *TFonc_Call)(int Index);

Code :

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

1
2
3
4
5
6
 
void __fastcall TBeginningCPPMainForm::Button1Click(TObject *Sender)
{
  void *p = this->MethodAddress("F_1");
  (*((TFonc_Call*)&p))(-2); // Comment forcer les transtypages, C++ est un peut pénible avec les type pointeurs de fonction, en Delphi, il ne fait pas le difficile !
}

L'exemple Delphi que tu as donné, je ne l'avais pas vu mais il est très mal fait, il manque "of object" dans les déclarations des TFunctionCall, supposant Obj comme 1er paramètre, ce n'est pas très propre, "__closure" semble être l'équivalent du "of object" de Delphi et il n'utilise pas non plus TMethod qui est la bonne méthode pour encaspuler de méthodes d'une classe, surtout lorsqu'elle sont publiées (tel les gestionnaire d'évènements)

Code :

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

1
2
3
4
5
6
7
void __fastcall TBeginningCPPMainForm::Button1Click(TObject *Sender)
{
  TMethod AddressMethod;
  AddressMethod.Code = this->MethodAddress("F_1");
  AddressMethod.Data = this;
  (*((TFonc_Call*)&AddressMethod))(-1); //toujours cette syntaxe rigolote !
}

on peut pour la suite simplifié avec une macro

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#define Call_TMethod(Adr, FnType) (*((FnType*)&Adr))
 
void __fastcall TBeginningCPPMainForm::Button1Click(TObject *Sender)
{
  TMethod AddressMethod;
  AddressMethod.Code = this->MethodAddress("F_1");
  AddressMethod.Data = this;
  Call_TMethod(AddressMethod, TFonc_Call)(-1);
}

Aller soyons fou !

Code :

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

1
2
3
4
5
6
7
#define Call_TMethod(Adr, FnType) (*((FnType*)&Adr))
#define Call_TFonc_Call(Obj, FnName, FnType) TMethod a; a.Code = Obj->MethodAddress(FnName); a.Data = Obj; Call_TMethod(a, FnType)
 
void __fastcall TBeginningCPPMainForm::Button1Click(TObject *Sender)
{
  Call_TFonc_Call(this, "F_1", TFonc_Call)(-1);
}

Tu peux aussi faire des fonctions qui encaspule les appels au lieu de faire des macros mais moi je trouvais ça drôle à tenter !

Maintenant avec une fonction !

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
typedef int __fastcall (__closure *TFonc_Call)(int Index, int Mul);
 
        int __fastcall TBeginningCPPMainForm::F_1(int Index, int Mul)
        {
          ShowMessage(Index);
          return Index * Mul;
        }
 
#define Call_TMethod(Adr, FnType) (*((FnType*)&Adr))
 
void __fastcall TBeginningCPPMainForm::Button1Click(TObject *Sender)
{
  TMethod AddressMethod;
  AddressMethod.Code = this->MethodAddress("F_1");
  AddressMethod.Data = this;
  ShowMessage((*((TFonc_Call*)&AddressMethod))(-1, 10));
  ShowMessage(Call_TMethod(AddressMethod, TFonc_Call)(-2, 100));
 
  void *p = this->MethodAddress("F_1");
  ShowMessage((*((TFonc_Call*)&p))(-3, 1000));
}

**noahsaga** · 05/04/2011, 16h51

Bon les __fastcall sont rajoutés.

J'avoue que la méthode macro est extrêmement élégante...
Je vais tenter de la faire fonctionner.

la partie :

Code :

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

1
2
#define Call_TMethod(Adr, FnType) (*((FnType*)&Adr))
#define Call_TFonc_Call(Obj, FnName, FnType) TMethod a; a.Code = Obj->MethodAddress(FnName); a.Data = Obj; Call_TMethod(a, FnType)

se met bien dans le .h?

et l'appel de cette macro remplace complètement cela ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#define Call_TMethod(Adr, FnType) (*((FnType*)&Adr))
 
void __fastcall TBeginningCPPMainForm::Button1Click(TObject *Sender)
{
  TMethod AddressMethod;
  AddressMethod.Code = this->MethodAddress("F_1");
  AddressMethod.Data = this;
  ShowMessage((*((TFonc_Call*)&AddressMethod))(-1, 10));
  ShowMessage(Call_TMethod(AddressMethod, TFonc_Call)(-2, 100));
 
  void *p = this->MethodAddress("F_1");
  ShowMessage((*((TFonc_Call*)&p))(-3, 1000));
}

En tout cas, merci

Je reviens dès que j'ai soit un résultat soit qqchose que je ne comprends pas.

**noahsaga** · 05/04/2011, 17h31

Bon et bien ça marche impeccable...
J'ai fait la méthode de la macro et c'est maGnifique

Encore merci!

Un peu de code pour ceux qui chercherait à faire un truc aussi farfelu :

le .h de la form contenant la classe :

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
class f_centrale : public TObject
{
private:
 
public:
        __fastcall f_centrale(TComponent* Owner);
        __fastcall ~f_centrale();
 
        //structure pour stocker les infos concernant les noeuds de test.
        struct Noeud
        {
          AnsiString nom;
          AnsiString id;
          bool present;
        };
        //init d'un tableau de noeud
        Noeud noeud[20];
 
        //contien le chemin du fichier fiche.ini
        AnsiString chemin;
 
        TIniFile *ini_f; //fichier ini de la BDD
 
__published:
        //Fonctions électriques
        void __fastcall Res_Isol_Cmd(int Index);
        void __fastcall Res_Isol_Mot(int Index);
        void __fastcall Res_Cont_Masse(int Index);
        //Fonctions Purge
        void __fastcall Remp_Huile(int Index);
        void __fastcall Purge_ACC(int Index);
        void __fastcall Purge_P2(int Index);
        void __fastcall Purge_P1(int Index);
        //fonctions accumulateur
        void __fastcall Mont_Press_ACC_1(int Index);
        void __fastcall Etanch_ACC(int Index);
        void __fastcall Dech_Manu(int Index);
        void __fastcall Mont_Press_ACC_2(int Index);
        void __fastcall Test_Limiteur(int Index);
        void __fastcall Test_Renifl(int Index);
        //Fonctions EIN 1
        void __fastcall Activ_EIN_1(int Index);
        void __fastcall Ctrl_EIN_1_OFF(int Index);
        void __fastcall Ctrl_IT(int Index);
        void __fastcall Etanch_EIN_1(int Index);
        void __fastcall Ser_Secu_EIN_1(int Index);
        void __fastcall Deser_Secu_EIN_1(int Index);
        void __fastcall Test_EV_G_1(int Index);
        void __fastcall Test_Capt_Pres_EIN_1(int Index);
        void __fastcall Mes_Tps_Mont_EIN_1(int Index);
        void __fastcall Mes_Tps_Desc_EIN_1(int Index);
        //Fonctions EIN 2
        void __fastcall Activ_EIN_2(int Index);
        void __fastcall Ctrl_EIN_2_OFF(int Index);
        void __fastcall Ser_Secu_EIN_2(int Index);
        void __fastcall Deser_Secu_EIN_2(int Index);
        void __fastcall Test_EV_G_2(int Index);
        void __fastcall Test_Capt_Pres_EIN_2(int Index);
        void __fastcall Mes_Tps_Mont_EIN_2(int Index);
        void __fastcall Mes_Tps_Desc_EIN_2(int Index);
};
 
typedef void __fastcall (__closure *TFonc_Call)(int Index);

Le .cpp est sans intêret ici.

le .h de la form appelant les fonctions :

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
 
//macro pour l'appel paramétrique des fonctions de test.
#define Call_TMethod(Adr, FnType) (*((FnType*)&Adr))
#define Call_TFonc_Call(Obj, FnName, FnType) TMethod a; a.Code = Obj->MethodAddress(FnName); a.Data = Obj; Call_TMethod(a, FnType)
 
class Tecran_essai : public TForm
{
...
 
Public:
...
 
        AnsiString nom_fonc; //nom de la fonction à appeler
        f_centrale *FFonc;
};
//---------------------------------------------------------------------------
extern PACKAGE Tecran_essai *ecran_essai;
//---------------------------------------------------------------------------
 
#endif

et le bout de cpp correspondant :

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
 
__fastcall Tecran_essai::Tecran_essai(TComponent* Owner)
        : TForm(Owner)
{
  //création de l'élément de la classe permettant de l'appel de fonction par AnsiString
  FFonc = new f_centrale(this);
...
 
void __fastcall Tecran_essai::UpDown1Click(TObject *Sender,
      TUDBtnType Button)  //on teste avec un updown bouton
{
  int i = UpDown1->Position;
 
  cltree->NodeActif = i;
 
  if (cltree->Items->Item[i]->Level == 2) //niveau des fonctions
  {
    i = i+3; //le nom de la fonction à appeler est le 3eme enfant du noeud
    nom_fonc = cltree->Items->Item[i]->Text;    //création de la chaine contenant   le nom de la fonction
 
    Call_TFonc_Call(FFonc,nom_fonc , TFonc_Call)(UpDown1->Position);
  }
}

**noahsaga** · 15/04/2011, 09h47

Un petit plus pour compléter le sujet.

Je veux récupérer une donnée (un int) à l'exécution des fonctions :

Comment modifier la macro pour que ce soit pris en compte?

Code :

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

1
2
3
4
5
6
7
8
9
10
11

typedef int __fastcall (__closure *TFonc_Call)(int Index);

#define Call_TMethod(Adr, FnType) (*((FnType*)&Adr))
#define Call_TFonc_Call(Obj, FnName, FnType) TMethod a; a.Code = Obj->MethodAddress(FnName); a.Data = Obj; Call_TMethod(a, FnType)
 
void __fastcall TBeginningCPPMainForm::Button1Click(TObject *Sender)
{
  Call_TFonc_Call(this, "F_1", TFonc_Call)(-1);
}

Voici comment je l'imagine :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12

typedef int __fastcall (__closure *TFonc_Call)(int Index);

#define Call_TMethod(Result, Adr, FnType) Result = (*((FnType*)&Adr))
#define Call_TFonc_Call(Obj, FnName, Result, FnType) TMethod a; a.Code = Obj->MethodAddress(FnName); a.Data = Obj; Call_TMethod(Result, a, FnType)
 
void __fastcall TBeginningCPPMainForm::Button1Click(TObject *Sender)
{
  int resultat;
  Call_TFonc_Call(this, "F_1", resultat, TFonc_Call)(-1);
}

**noahsaga** · 15/04/2011, 10h08

Bon ben ça fonctionne comme je l'ai écrit au dessus

Ça fait un post de complément au sujet...

**ShaiLeTroll** · 15/04/2011, 10h11

Tu n'as pas besoin de modifier la macro, juste TFonc_Call
Regarde là, message du 05/04/2011, 16h16, dernier bloc de code j'avais déjà fait un exemple avec une fonction et deux paramètres

Code :

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

1
2
3
typedef int __fastcall (__closure *TFonc_Call)(int Index, int Mul);
...
int resultat= Call_TMethod(AddressMethod, TFonc_Call)(-2, 100);

**noahsaga** · 15/04/2011, 10h35

Ah oui ok. Mais il ne faut quand même pas modifier la 2 ème macro?

du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
typedef int __fastcall (__closure *TFonc_Call)(int Index);

#define Call_TMethod(Adr, FnType) (*((FnType*)&Adr))
#define Call_TFonc_Call(Obj, FnName, Result, FnType) TMethod a; a.Code = Obj->MethodAddress(FnName); a.Data = Obj; Result = Call_TMethod(a, FnType)
 
void __fastcall TBeginningCPPMainForm::Button1Click(TObject *Sender)
{
  int resultat;
  Call_TFonc_Call(this, "F_1", resultat, TFonc_Call)(-1);
}

**ShaiLeTroll** · 15/04/2011, 14h23

Oui, si tu veux utiliser Call_TFonc_Call, il faut gérer le Result comme tu l'as fait !
Perso, je préfèrerais utiliser Call_TMethod

Code :

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

1
2
3
4
5
  TMethod AddressMethod;
  AddressMethod.Code = this->MethodAddress("F_1");
  AddressMethod.Data = this;
 
  int resultat = Call_TMethod(AddressMethod, TFonc_Call)(-2, 100);

Le Code est plus long, mais je pense que même si Call_TFonc_Call est fonctionnelle, une macro aussi longue ce n'est terrible à maintenir !

si tu veux tu peux faire deux macros

Code :

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

1
2
3
 
#define Call_TMethod(FnType) (*((FnType*)&AddressMethod))
#define Get_TMethod(Obj, FnName) TMethod AddressMethod; AddressMethod.Code = Obj->MethodAddress(FnName); AddressMethod.Data = Obj;

Code :

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

1
2
3
 
  Get_TMethod(this, "F_1");  
  int resultat = Call_TMethod(TFonc_Call)(-2, 100);

**noahsaga** · 15/04/2011, 15h21

ok ça marche.

Au fait, petit clin d'oeil dans le code final:

**ShaiLeTroll** · 15/04/2011, 17h15

Tu devrais même mettre un lien sur la discussion, si un autre développeur reprend ton appli dans quelques mois ou années, il sera content de comprendre le cheminement qui a amener cette solution !

Appel d'une fonction/TThread de façon paramétrique

C++Builder

Discussions similaires

Partager

Partager