Utilisez #ifdefs et #define pour activer un appel de fonction dans un commentaire

Est-il possible de faire quelque chose comme ceci

#ifdef SOMETHING
#define foo //
#else
#define foo MyFunction
#endif

L'idée est que si quelque CHOSE est définie, puis appelle toto(...) deviennent des commentaires (ou quelque chose qui n'est pas évalué ou compilé), sinon c'est un appel à la fonction MyFunction.

J'ai vu __noop utilisé, mais je ne crois pas que je peux utiliser.

MODIFIER(s):

Je ne pense pas que je peux vraiment utiliser une macro ici, parce que Mafonction prend un nombre variable d'arguments.

Aussi, j'aimerais faire en sorte que les arguments ne sont PAS évalués! (Donc faire quelque chose comme commentant le corps de la fonction MyFunction n'a pas vraiment de me donner ce dont j'ai besoin, que les arguments seront toujours évalués)

source d'informationauteur Daniel LeCheminant

c c++c-preprocessor conditional-compilation

24

Essayez ceci:
```
#ifdef SOMETHING
#define foo(x)
#else
#define foo(x) MyFunction(x)
#endif
```
Si votre fonction a plusieurs arguments, puis:
```
#ifdef SOMETHING
#define foo(x,y,z)
#else
#define foo(x,y,z) MyFunction(x,y,z)
#endif
```
Si votre fonction a un nombre variable d'arguments, alors votre compilateur peut soutenir les soi-disant "variadic macros", comme ceci:
```
#ifdef SOMETHING
#define foo(...)
#else
#define foo(...) MyFunction(__VA_ARGS__)
#endif
```
La raison pour laquelle j'ai vu ce genre de chose utilisé dans la pratique est de se débarrasser des fonctions de journalisation à partir d'une version de construire. Cependant, voir aussi À part "debug" et "release" construit? dans lequel les gens question de savoir si vous devrait même ont différents builds.

Alternativement, au lieu de la redéfinition de la fonction d'appel en tant que rien, Jonathan commentaire pour cette réponse a suggéré de faire quelque chose comme ce qui suit:
```
#ifdef SOMETHING
#define foo(...) do { if (false) MyFunction(__VA_ARGS__) } while (0)
#else
#define foo(...) do { if (true) MyFunction(__VA_ARGS__) } while (0)
#endif
```
Le raisonnement pour le faire, c'est donc que l'appel de fonction est toujours compilé (afin de ne pas être de gauche avec de gratuit erreurs comme des références à supprimé de variables), mais seulement appelé en cas de besoin: voir Kernighan & Brochet La Pratique de la Programmation et aussi la Centre de Vol spatial Goddard de la programmation des normes.

De débogage.h fichier (originaires de 1990, et n'est donc pas à l'aide de __VA_ARGS__):
```
/*
** Usage:  TRACE((level, fmt, ...))
** "level" is the debugging level which must be operational for the output
** to appear. "fmt" is a printf format string. "..." is whatever extra
** arguments fmt requires (possibly nothing).
** The non-debug macro means that the code is validated but never called.
** -- See chapter 8 of 'The Practice of Programming', by Kernighan and Pike.
*/
#ifdef DEBUG
#define TRACE(x)    db_print x
#else
#define TRACE(x)    do { if (0) db_print x; } while (0)
#endif /* DEBUG */
```
Avec C99, il n'y a plus besoin de la double parenthèses truc. Le nouveau code ne devrait pas l'utiliser à moins que C89 la compatibilité est un problème.
5

Peut-être un moyen plus facile de le faire serait conditionnelle, omettre le corps de la fonction?
```
void MyFunction() {
#ifndef SOMETHING
    <body of function>
#endif
}
```
Sauf si vous ne voulez pas d'un appel de fonction à être déployés à tous, cela semble être un moyen propre à atteindre votre objectif.

Malheureusement, l'actuelle version C++ ne prend pas en charge variadic macros.

Cependant, vous pouvez faire ceci:

#ifdef SOMETHING
#define foo
#else
#define foo(args) MyFunction args
#endif

//you call it with double parens:
foo((a, b, c));

2

Si, dans le cas où vous ne voulez pas foo appelé, vous définissez comme:
```
void foo() {}
```
tous les appels à des foo() doit être optimisé.

Que penser de quelque chose le long de ces lignes:

#ifdef NDEBUG
#define DEBUG(STATEMENT) ((void)0)
#else
#define DEBUG(STATEMENT) (STATEMENT)
#endif

Que vous pouvez l'utiliser comme cela pour le journal des messages de débogage:

DEBUG(puts("compile with -DNDEBUG and I'm gone"));

Un non-générique version pour une sortie formatée avec d'autres informations de débogage à l'aide de C99 variadic les macros et les __func__ identificateur pourrait ressembler à ceci:

#ifdef NDEBUG
#define Dprintf(FORMAT, ...) ((void)0)
#define Dputs(MSG) ((void)0)
#else
#define Dprintf(FORMAT, ...) \
    fprintf(stderr, "%s() in %s, line %i: " FORMAT "\n", \
        __func__, __FILE__, __LINE__, __VA_ARGS__)
#define Dputs(MSG) Dprintf("%s", MSG)
#endif

Voici comment vous pouvez utiliser ces macros:

Dprintf("count = %i", count);
Dputs("checkpoint passed");

2

Probablement, vous ne voulez pas faire de la simple "code de l'enlèvement", comme l'a suggéré,
parce que vos interlocuteurs attendent les effets secondaires de la
les arguments de se produire. Voici quelques gênants appelant les fragments de code
devrait vous faire réfléchir:
```
//pre/post increment inside method call:
MyFunction(i++); 

//Function call (with side effects) used as method argument: 
MyFunction( StoreNewUsernameIntoDatabase(username) ); 
```
Si vous désactivez la fonction MyFunction en disant simplement:
```
#define MyFunction(x) 
```
puis les effets secondaires que les appelants étaient attend irait loin,
et leur code de casser, et être assez difficile à déboguer. J'aime
le "sizeof" suggestion ci-dessus, et j'aime aussi la suggestion à la juste
désactiver le corps de la fonction MyFunction() via #ifdef, même si cela signifie
que toutes les personnes de la même version de la fonction MyFunction(). À partir de votre
énoncé du problème, je suppose que c'est pas vraiment ce que vous voulez.

Si vous avez vraiment besoin de désactiver la fonction MyFunction() par l'intermédiaire de préprocesseur sur
par source de fichier de base, alors je ferais comme ceci:
```
#ifdef SOMETHING 
#define MyFunction(x) NoOp_MyFunction(x) 

int NoOp_MyFunction(x) { } 
#endif 
```
Vous pouvez même inclure la mise en œuvre de NoOp_MyFunction() à l'intérieur de
la source & les en-têtes pour MyFunction(). Vous avez également la flexibilité
ajouter de l'exploitation forestière ou des informations de débogage dans NoOp_MyFunction()
bien.
1

Non, le C et le C++ Normes de dire que vous ne pouvez pas #define quelque chose pour être un commentaire, si
```
#define foo //
```
ne fonctionne pas.
1
```
#ifdef SOMETHING
#define foo sizeof
#else
#define foo MyFunction
#endif
```
Je suis en supposant que toto est un printf style de fonction? De toute façon, cela ne fonctionne pas avec un zéro paramètre de la fonction, mais si c'était le cas, vous savez déjà quoi faire. Si vous voulez vraiment être anal vous pouvez utiliser (void)sizeof mais c'est probablement inutile.
1

Je suis un peu réticent à publier cette réponse parce que c'est l'utilisation de la macro hackery peut devenir une source de problèmes. Toutefois - si les appels à la fonction que vous voulez avoir disparaissent sont toujours utilisé seul dans une déclaration (ie., ils ne font jamais partie d'une expression plus grande), alors quelque chose comme ce qui suit pourrait travailler (et il gère varargs):
```
#ifdef SOMETHING
#define foo (1) ? ((void) 0) : (void)
#else
#define foo MyFunction
#endif
```
Donc, si vous avez la ligne de code:
```
foo( "this is a %s - a++ is %d\n", "test", a++);
```
il se trouvera après l'étape de prétraitement comme:
```
MyFunction( "this is a %s - a++ is %d\n", "test", a++);
```
ou
```
(1) ? ((void) 0) : (void)( "this is a %s - a++ is %d\n", "test", a++);
```
qui transforme la pseudo-fonction de la liste de paramètres dans un tas d'expressions séparées par l'opérateur virgule qui ne sera jamais évalué, puisque la condition renvoie toujours le ((void) 0) résultat.

Une variante de ce est quelque chose de proche de ce que ChriSW et Jonathan Leffler a suggéré:
```
#ifdef SOMETHING
#define foo if (0) MyFunction
#else
#define foo if (1) MyFunction
#endif
```
C'est un peu différent en ce qu'il ne nécessite pas le compilateur à l'appui de variadic macros (__VA_ARGS__).

Je pense que cela peut être utile pour éliminer les traces de débogage des appels de fonction qui sont généralement jamais réunis dans une expression plus grande, mais au-delà je pense que c'est un dangereux technique.

Note le risque de problèmes - en particulier si les paramètres dans l'appel de produire des effets secondaires (c'est un problème général avec les macros - pas seulement ce hack). Dans l'exemple, le a++ sera évaluée uniquement si SOMETHING est défini dans le build, sinon il ne l'est pas. Donc, si le code après l'appel dépend de la valeur de a être incrémenté, l'un des builds a un bug.
0

Si je me souviens bien, vous devriez être en mesure de #define votre macro pour "rien" et qui va provoquer le compilateur d'ignorer cet appel
```
#define foo()

foo();    //this will be ignored
```
0

Qu'en entourant chaque appel à la fonction myFunction avec
```
#ifdef SOMETHING
myFunction(...);
#endif
```
?

Vous devez vous connecter pour publier un commentaire.