Discussion :

[Bruiser]

Le programme sur lequel je travail est constitué d'un grand nombre de fonction (dans mon exemple je les nomme : fonction1, fonction2, etc..., elle renvoi un AnsiString) et à chaque fois que j'utilise l'une d'entre elle je dois calculer leurs paramètres et faire d'autre opération.
Si j'écris ces opérations à l'appel chaque fonction, ça va me faire un code super long et répétitif.
Comme ces opérations et calcul sont les mêmes pour chaque fonctions, j'ai envi de les mettre dans une fonction qui les ferait et appellerai la fonction qu'on lui à passé en paramètre (fonction1 ou fonction2 ou ...).


J'ai cherché du coté des pointeurs de fonction et j'ai trouvé pas mal de chose, mais je n'ai rien réussit à faire marché. Je n'ai pas tout compris non plus, je suis débutant en pointeur.

Voici, de façon simplifié, ce que je souhaite faire :

Code :

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

1
2
3
4
5
6
7
8
9
"fonctionN" = &fonction1;  //pointeur sur la fonction qui sera passer en paramètre
RemplirCase( a, b, "fonctionN");
 
//----------------------------------
void RemplirCase(int a,int b, "fonctionN")
{
offset=a+b;
AnsiString data = fonctionN(offset,1);
}

j'ai essayé ceci pour créer le pointeur :

.h

Code :

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

AnsiString __fastcall Fonction1(int offset);

.cpp

Code :

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

1
2
   AnsiString ( *pFonction1)(int) = NULL;
pFonction1 = &Fonction1;

Mais j'ai une erreur à la dernière ligne : E2034 Impossible de convertir 'AnsiString (_fastcall * (_closure )(int))(int)' en 'AnsiString (*)(int)

Quelqu'un pourrait-il m'aider?

Merci.

[sat83]

Je n'ai pas C++ Builder sous la main, mais voilà quelquechose qui devrai fonctionner :

Code :

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

1
2
3
4
5
 
//Déclaration du prototype de ta fonction qui sera passée en paramètre
typedef void (__closure *MyParameterFunction) ( int a, int b ) ;
//Déclaration d'une fonction dont un paramètre est un pointeur vers ta fonction déclarée précedement
AnsiString MyFunction( int i, MyParameterFunction aFunction ) ;

et dans le cpp:

Code :

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

1
2
3
4
5
6
AnsiString MyFunction( int i, MyParameterFunction aFunction )
{
  int tmpInt = 10;
  int tmpInt2 = 10 * i ;
  aFunction( tmpInt , tmpInt2  ) ; // appel a ta fonction
}

[sat83]

Un exemple sera peut etre plus explicatif :

dans le *.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
//déclaration du prototype de ta fonction
typedef int (__closure *Operation) ( int, int ) ; 
 
class TForm1 : public TForm
{
//[...]
private:
   int Addition( int x, int y ) ; 
   int Multiplication( int x, int y ) ;
   void ExecuteFonction( int i, int j, Operation aFunction ) ; 
};

dans 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
int TForm1::Addition( int x, int y )
{
  return( x+y ) ;
}
//------------------------------------------
int TForm1::Multiplication( int x, int y )
{
  return( x*y ) ;
}
//------------------------------------------
void TForm1::ExecuteFonction( int i, int j, Operation aFunction )
{
//Execution de la fonction passée en paramètre sans la connaitre a l'avance
  int result = aFunction( i, j );
//Affichage du résultat.
  ShowMessage( IntToStr( result ));
}

A l'exécution, exemple avec deux boutons, chacun faisant appel à la même méthode (ExecuteFunction) mais effectuant 2 actions différentes selon la méthode passée en paramètre:

Code :

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

1
2
3
4
5
6
7
8
9
10
//------------------------------------------
void __fastcall TForm1::BitBtn1Click(TObject *Sender)
{
  ExecuteFonction( 10, 10, Addition ) ;
}
//---------------------------------------------------
void __fastcall TForm1::BitBtn2Click(TObject *Sender)
{
  ExecuteFonction( 10, 10, Multiplication ) ;
}

[henderson]

Salut !

Si j'écris ces opérations à l'appel chaque fonction, ça va me faire un code super long et répétitif.
Comme ces opérations et calcul sont les mêmes pour chaque fonctions, j'ai envi de les mettre dans une fonction qui les ferait et appellerai la fonction qu'on lui à passé en paramètre (fonction1 ou fonction2 ou ...).

Tu as probablement, au niveau de ton projet, un problème de conception à résoudre !
Parce que :

Comme ces opérations et calcul sont les mêmes pour chaque fonctions,

A mon avis ... il y a un problème bien avant celui de la déclaration d'un pointeur vers méthode (ou vers fonction) !

A plus !

[Bruiser]

Merci beaucoup sat83, c'est exactement ce qu'il me fallait.

@ henderson : En faite mon programme permet de lire et décoder des données contenues dans un fichier, le but est d'afficher ces données dans un tableau en fonction de ce que souhaite voir l'utilisateur.
Ce fichier est constitué de 15 pages, chaque pages et constitué de 255 fiche contenant des données (un grands nombre ) toutes codées de façon différente.
Il me faut donc une fonction par donner à décoder.
Pour faire le décodage mes fonctions ont besoin de connaitre l'emplacement en mémoire des octets à lire, c'est ce que je calcul avant l'exécution de mes fonctions, j'ajoute également des colonnes à mon tableau à ce moment là. Ça ne prend que 10 lignes, mais 10 lignes fois le nombre de données ça fait beaucoup, c'est ce que je souhaite ainsi éviter.

C'est pour cela que c'est répétitif. Enfin c'est un peut long à expliquer, je ne sais pas si j'ai été clair, mais je n'ai pas trouvé d'autre façon de faire.

[henderson]

Salut !

En fait ... tout dépend de l'organisation des données dans chaque fiche parmi les 255 d'une page parmi 15 pages !

Par exemple, si les fiches reposent sur un même modèle, on peut alors imaginer un tableau de pointeurs vers fonction pour résoudre chaque champ.
Et dans ce cas, il ne serait plus nécessaire de passer une fonction comme paramètre.
Ce tableau étant initialisé une fois pour toutes, une simple boucle (pour traiter une fiche) suffirait pour solliciter la bonne fonction pour la bonne donnée.
Et dans ce cas précis, on pourrait envisager de passer un pointeur vers AinsiString et un pointeur vers int pour passer d'un champ à l'autre ...

Mais bon ... chacun fait bien comme il veut... du moment que ça fonctionne !

A plus !