Pointeurs fonctions de types inconnus

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.

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érents paramètres. Les plantages sont assurés quand ce ne sont pas les bons. Plus le nombre de paramètres augmente et plus les chances diminuent. Il faut penser aussi à la convention d'appel.
Bonne chance quand-même.

Un pointeur géné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;
}

Essaye de forcer le compilo à convertir ta fonction lorsque tu veut récuperer son pointeur dans pointeurFonction:

void* pointeurFonction;
pointeurFonction = (void*)fonctionAlacon;

Je suis pas sur que ça marche sur les fonctions mais essaye quand même

neodelphi

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++

et prévoir remontée de ESP si func non stdcall.

ciao...
BruNews, MVP VC++

C'est marrant, il me semblais qu'on ne pouvais affecter l'adresse d'une fonction à un pointeur générique, j'aurais revé ?

J'ai pas revé, le standard l'interdit.

On peut définir un type de pointeur de fonction comme ceci:
typedef  BOOL (*PFonction)(int);
On définit ici un pointeur d'une fonction qui renvoie un BOOL et reçoit un int comme paramètre.
Pour dé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écisée. Dans ce cas le compilateur utilise la convention par défaut : __cdecl. Pour la préciser dans la définition du type de pointeur on fait par exemple:
typedef  BOOL (__stdcall *PFonction)(int);

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.