Macro et fonction avec le même nom

Question

J'ai le code

#define myfunc(a,b) myfunc(do_a(a), do_b(b)) 

void myfunc(int a, int b) 
{ 
    do_blah(a,b); 
} 
int main() 
{ 
    int x = 6, y = 7; 
    myfunc(x,y); 

    return 0; 
} 

suivant, je veux que le pré-processeur pour étendre la fonction myfunc seulement à appeler. Code requis après le pré-traitement ressemble à ceci:

void myfunc(int a, int b) 
{ 
    do_blah(a,b); 
} 
int main() 
{ 
    int x = 6, y = 7; 
    myfunc(do_a(x),do_b(y)); 

    return 0; 
} 

Le problème est que la définition de la fonction est également étendu comme celui-ci

void myfunc(do_a(int a), do_b(int b)) 
{ 
    do_blah(a,b); 
} 

Est-il possible de faire macro est que si nous élargissons une fonction appel? J'ai essayé beaucoup de solutions, et il semble impossible, mais j'espère que quelqu'un a vu la situation comme ça ..

REMARQUE: s'il vous plaît ne me dites pas de renommer les noms de macro ou fonction: D

Update1: Merci pour ton aide. Mais je ne peux que changer la définition de la macro, je ne peux pas changer sa position et je ne peux pas changer la mise en œuvre de la fonction.

Answer 1

Utilisez () pour arrêter le préprocesseur d'élargir la définition de la fonction:

#include <stdio.h> 

#define myfunc(a, b) myfunc(do_a(a), do_b(b)) 
/* if you have a preprocessor that may be non-standard 
* and enter a loop for the previous definition, define 
* myfunc with an extra set of parenthesis: 
#define myfunc(a, b) (myfunc)(do_a(a), do_b(b)) 
******** */ 

int (myfunc)(int a, int b) /* myfunc does not get expanded here */ 
{ 
    printf("a=%d; b=%d\n", a, b); 
    return 0; 
} 

int do_a(int a) 
{ 
    return a * 2; 
} 

int do_b(int b) 
{ 
    return b - 5; 
} 

int main(void) 
{ 
    myfunc(4, 0); 
    return 0; 
} 

Answer 2

Définissez la macro après avoir défini la fonction.

Vous pouvez également utiliser un modèle comme celui-ci:

#define myfunc_macro(a,b) myfunc(do_a(a), do_b(b)) 
#define myfunc(a,b) myfunc_macro(a,b) 

. 
. 

#undef myfunc 
void myfunc(int a, int b) 
{ 
    do_blah(a,b); 
} 
#define myfunc(a,b) myfunc_macro(a,b) 

. 
. 

int main() 
{ 
    int x = 6, y = 7; 
    myfunc(x,y); 

    return 0; 
} 

Answer 3

Définir le macro après la défintion de la fonction.

void myfunc(int a, int b) 
{ 
    do_blah(a,b); 
} 

#define myfunc(a,b) myfunc(do_a(a), do_b(b)) 

int main() 
{ 
    int x = 6, y = 7; 
    myfunc(x,y); 

    return 0; 
} 

Answer 4

Je vois trois solutions possibles:

• votre macro après définissent la définition de la fonction.

• définir, avant la définition de la fonction, do_a() et do_b() de telle sorte qu'ils retournent leur argumentation, et les redéfinir à votre volonté après la définition de la fonction

• effectuer do_a() et do_b() dans la fonction:

  void myfunc(int a, int b) 
  { 
      do_blah(do_a(a),do_b(b)); 
  } 
  

J'ai une forte préférence pour ce dernier. Pourquoi ne pas changer le code source?

Answer 5

Au pire, si vous devez conserver la version d'origine, exécutez un patch dessus pour créer un fichier temporaire dans lequel la fonction est renommée et la compiler à partir de là.