Pointeurs fonctions de types inconnus

Question

Bien le bonjour,

J`aimerai recuperer des pointeurs vers des fonctions dont je ne connais pas le type a l`avance.

Ex:

DWORD FonctionAlacon(char* pStr)
{
  return  strlen(pStr) - strlen(pStr);  // alors ca pour une fonction a la con, ... !

}

int main(void)
{
 void*  pointeurFunction;
 pointeurFunction = FonctionAlacon;

 return 0;
}

Ca ne compile pas car il faut preciser les arguments et parametres. Mais je n`peux pas car je ne connais pas les fonctions a l`avance.

Comment resoudre ce probleme ?

Je vous remercie.

racpp · Answer

Bonjour,

Sans documentation sur cette fonction, il est difficile de trouver son
type de pointeur. Avec beaucoup de chance, tu y arriveras en faisant
des tests avec diff&#233;rents param&#232;tres. Les plantages sont assur&#233;s quand
ce ne sont pas les bons. Plus le nombre de param&#232;tres augmente et plus
les chances diminuent. Il faut penser aussi &#224; la convention d'appel.

Bonne chance quand-m&#234;me.

steve_clamage · Answer

Un pointeur g&#233;n&#233;ric ne peut pas contenir l'adresse d'une fonction,
seulement d'un objet. Tu peux passer par une structure par exemple.





DWORD FonctionAlacon(char* pStr)

{

  return  strlen(pStr) - strlen(pStr);

}



struct s_Fonction{

DWORD (*FonctionAlacon)(char* pStr)

}f = {FonctionAlacon };



int main(void)

{

 void*  pointeurFunction;

 pointeurFunction = &f;



 ((struct s_Fonction *)f)->FonctionAlacon...

 return 0;

}

neodelphi · Answer

Essaye de forcer le compilo &#224; convertir ta fonction lorsque tu veut r&#233;cuperer son pointeur dans pointeurFonction:

void* pointeurFonction;
pointeurFonction = (void*)fonctionAlacon;

Je suis pas sur que &#231;a marche sur les fonctions mais essaye quand m&#234;me 

neodelphi

BruNews · Answer

Comme dit racpp, le seul prob ce sont les params (nbr et type) sinon:

pfunc = GetProcAddress(hdll, "nomFunc);

quand appel, si 3 params par exemple:


__ asm {
  push  param3
  push  param2
  push  param1
  call  pfunc
}

et on se soucie plus des contorsions de cast du C.

ciao...
BruNews, MVP VC++

BruNews · Answer

et pr&#233;voir remont&#233;e de ESP si func non stdcall.

ciao...
BruNews, MVP VC++

steve_clamage · Answer

C'est marrant, il me semblais qu'on ne pouvais affecter l'adresse d'une fonction &#224; un pointeur g&#233;n&#233;rique, j'aurais rev&#233; ?

steve_clamage · Answer

J'ai pas rev&#233;, le standard l'interdit.

racpp · Answer

On peut d&#233;finir un type de pointeur de fonction comme ceci:

typedef  BOOL (*PFonction)(int);

On d&#233;finit ici un pointeur d'une fonction qui renvoie un BOOL et re&#231;oit un int comme param&#232;tre.

Pour d&#233;clarer notre pointeur on  fait:

PFonction pf;

Pour lui affecter l'adresse d'une fonction on fait:

pf = (PFonction) NotreFonction;

Ainsi, on peut remplacer NotreFonction par pf dans le programme.

Dans cet exemple, la convention d'appel  n'est pas pr&#233;cis&#233;e. Dans
ce cas le compilateur utilise la convention par d&#233;faut : __cdecl. Pour
la pr&#233;ciser dans la d&#233;finition du type de pointeur on fait par exemple:

typedef  BOOL (__stdcall *PFonction)(int);

Galmiza · Answer

Merci a tous !

Je vais donc definir un type commun a toutes les fonctions (que je dois modifier):

typedef  void (__stdcall *VOID_FUNC)(void*);

A coup de memcopy, ca devrait aller pour renvoyer et recevoir n`importe quel type d`argument .

Ex:

void func1(void* pData)
{
  BYTE *b = (BYTE*)pData;
  float f1 = 0.7f;
  float f2 = 0.9f;
  float f3 = 7.4f;
  memcpy(b, &f1, sizeof(float));  b+=sizeof(float);
  memcpy(b, &f2, sizeof(float));  b+=sizeof(float);
  memcpy(b, &f3, sizeof(float));  b+=sizeof(float);
}

VOID_FUNC pf;
BYTE byte[3*sizeof(float)];
pf = func1;

pf(byte);

Merci encore.

steve_clamage · Answer

Tu peux simplifier



void func1(void* pData)
{
 static const float f[] = {0.7f, 0.9f, 7.4f};  
 memcpy(pData, f, sizeof f);
}

VOID_FUNC pf;
float f[3];
pf = func1;

pf(f);

Galmiza · Answer

Oui, c`est vrai, j`aurais du prendre un exemple avec differents types de parametres.

steve_clamage · Answer

Dans ce cas passe plutot une structure:



struct Params

{

int i;

float f;

};


 void func1(void* pData)
{
 struct Params *params = pData;

 params->i = 5;

 params->f = 27.1f;
}



VOID_FUNC pf;
struct Params params;
pf = func1;

pf(&params);

xterminhate · Answer

Par curiosit&#233;, j'aimerais savoir ce que tu veux faire exactement ?! Le "pourquoi du comment".



Avec des possibilit&#233;s comme le polymorphise param&#233;trique ou le
polymorphisme d'ex&#233;cution, je ne vois vraiment pas quelle application
amene &#224; devoir empiler des (void)(void*)(void*).

Cordialement,
   Xterminhate.

Galmiza · Answer

Bon, je ne vais pas raconter ma vie, mais je fais un editeur (trop long a expliquer).

J'ai donc fait une console pour modifier des donn&#233;es sans avoir a recompiler le programme.

Et j'ai besoin d'envoyer des actions comme.



SetTexture(3, {Group(5-8), 1,2-11}, {0});

Qui est cens&#233; appliquer la texture 3 aux 1er subset des meshes 1, 2 &#224; 11 et aux meshes appartenant au groupes 5 &#224; 8.



Bref, des trucs comme &#231;a.



Je dois analyser ces chaines de caracteres.

Facile de recuperer le nom de la fonction, le nombre de parametre et
les parametres "extraits" (genre 1-3 => 1,2,3  et  lecture
des groupes).



Le probleme est qu'il y a enormement de fonctions comme SetTexture. Des fonctions ayant besoin de parametres diff&#233;rents.

Je pensais ecrire les fonctions comme SetTexture dans le programme et leur envoyer les parametres lus dans la console.

Je voulais faire une structure pour toutes les fonctions.



struct SFunction

{

 char  s_strName[32];   // ex "SetTexture"

 BYTE  s_bNumParameters;

DWORD s_dwParameters[8];   // flags pour definir les parametres

VOID_FUNC  s_Function;   // pointeur vers une fonction

};



et faire:

for (i=0; i<m_dwNumFunction; i++)

  if (StringCompare(strFuncName, objFunc[i].s_strName))

   (objFunc[i].s_Function)((BYTE*) pParameters );



Je voulais faire pointer s_Function vers des fonctions comme SetTexture qui prend comme parametres 1 int et 2 listes d'int.

Mais toutes les fonctions n'ont pas tous les meme types d'arguments....



Bon , je n'ai pas &#233;t&#233; clair, mais ce n'est pas grave.

Je teste d'autre methode... pour l'instant.

xterminhate · Answer

Ok, on retombe alors sur une application ordinaire du polymorphime d'execution en C++. Donc, pas besoin de cette merde de (void*)(void*). Je peux t'avancer une solution si tu n'est pas réticent à l'orienté objet et au C++.

Galmiza · Answer

Je suis ouvert a toutes propositions.

xterminhate · Answer

Bien, ce soir ou demain, je poste un nouveau source qui sera intitul&#233;
"Classe Interpreteur de commande" que tu pourras d&#233;river afin de
r&#233;aliser - en partie - ce que tu souhaites faire. J'ai moi m&#234;me un
besoin similaire et souvent r&#233;currant qui semble tres proche du tien.
Je vais donc le formaliser....

Cordialement,
   Xterminhate.

Galmiza · Answer

Merci infiniment !

Je vais de ce pas (\de ce clic) me renseigner sur les polymorphismes d`execution pour ne pas etre largue en lisant ta source.

Merci encore.

steve_clamage · Answer

xterminhate, ce que tu appels polymorphime d'execution c'est bien le
polymorphime d'inclusion (par le biais de l'heritage et de methodes
virtuelles) ?

xterminhate · Answer

Stevy > Exactement.

Cordialement,
   Xterminhate.

Pointeurs fonctions de types inconnus

21 réponses

Votre réponse

Discussions similaires