Pouvez-vous #définir un commentaire en C?

Je suis en train de faire un système de débogage, mais il semble ne pas fonctionner.

Ce que je voulais accomplir, c'est quelque chose comme ceci:

#ifndef DEBUG
    #define printd //
#else
    #define printd printf
#endif

Est-il un moyen de le faire? J'ai beaucoup de messages de débogage et que je ne les aime pas faire:

if (DEBUG)
    printf(...)

code

if (DEBUG)
    printf(...)

...

Direct en double de stackoverflow.com/questions/1644868/... et probablement d'autres aussi.
le cas d'utilisation (création d'un débogage d'impression macro) est un double de la stackoverflow.com/questions/1644868/..., mais le littéral question posée (puis-je inclure // dans un #define) n'est pas - et la véritable question posée est intéressante et utile pour les autres. Le chevauchement est malheureux, mais il y a une question distincte ici qui a de la valeur; il ne doit pas être fermé.
Le titre est un 'XY Problème' — la solution à ce que l'utilisateur cherche à atteindre est la nomination en double, mais la question est de demander quelque chose tangentielle qui n'est pas le même réaliser ce qu'ils veulent.
si vous pensez que le titre est problématique ou pas, je voudrais simplement ne pas avoir trouvé la réponse à ces questions ou pensé à faire les choses d'une certaine façon, si je n'ai pas cliqué sur ce titre dans les résultats de recherche Google. Pour moi les questions était plus sur la procédure de bande de code de production sans avoir besoin de #ifdefs partout, et grâce à des OP tangentielle question j'ai trouvé des idées qui m'ont mis sur la bonne voie. Je n'aurais pas cherché une question sur "debug"impression" --ce n'est simplement pas mon cas d'utilisation!

InformationsquelleAutor Ben B. | 2009-11-23

c c-preprocessor debugging

29

Non, vous ne pouvez pas. Les commentaires sont supprimés à partir du code avant tout traitement de prétraitement des directives de commencer. Pour cette raison, vous ne pouvez pas inclure des commentaires dans une macro.

Aussi, toutes les tentatives de "forme" d'un commentaire plus tard, par l'utilisation d'une macro la ruse ne sont pas garantis de travailler. Le compilateur n'est pas tenu de reconnaître la "fin" des commentaires de commentaires.

La meilleure façon de mettre en œuvre ce que vous voulez est d'utiliser des macros avec des arguments de variables en C99 (ou, peut-être, à l'aide du compilateur extensions).

InformationsquelleAutor AnT
20

Un truc commun est de faire ceci:
```
#ifdef DEBUG
  #define OUTPUT(x) printf x
#else
  #define OUTPUT(x)
#endif

#include <stdio.h>
int main(void)
{   
  OUTPUT(("%s line %i\n", __FILE__, __LINE__));

  return 0;
}
```
Cette façon, vous avez toute la puissance de printf() disponibles pour vous, mais vous devez mettre en place avec les deux crochets de faire de la macro de travail.

Le point de la double crochets est ceci: vous avez besoin d'un jeu, que c'est un appel de macro, mais vous ne pouvez pas avoir un nombre indéterminé d'arguments dans une macro en C89. Cependant, en mettant les arguments dans leur propre série de crochets, ils ont interprété comme un seul argument. Lorsque la macro est développée lorsque DEBUG est défini, le texte de remplacement est le mot printf suivie par la planif argument, qui est en fait plusieurs éléments entre crochets. Les crochets alors interprété comme les supports nécessaires à la printf appel de la fonction, de sorte que tout fonctionne.
- pourquoi ne pas utiliser printf(x) dans la 1ère macro ? ne fonctionne pas ?
- aussi, vous pouvez utiliser la SORTIE(x...) printf(x) pour éviter la double ().
- Ceci ne fonctionnerait pas si vous voulais un nombre variable d'arguments. Voir le texte explicatif pour plus de détails.
InformationsquelleAutor Tim
18

С99 façon:
```
#ifdef DEBUG
    #define printd(...) printf(__VA_ARGS__)
#else
    #define printd(...)
#endif
```
Bien, celui-ci ne nécessite pas de C99 mais elle suppose que le compilateur a l'optimisation activée pour version:
```
#ifdef DEBUG
    #define printd printf
#else
    #define printd if (1) {} else printf
#endif
```
- Correct, mais pas assez portable.
- Ajouté portable manière 🙂
- Beaucoup mieux, mais encore une fois le "portable" version n'a pas de désactiver la vérification de la validité des arguments. La bonne façon de le faire dans la non-C99 mise en œuvre est donnée dans la réponse de Tim.
- Et c'est son bon côté, je pense. Pourquoi désactiver le contrôle de validité sur le code qui sera vrai dans les versions de débogage?
- Simple: parce que le code peut ne pas être valide dans la version versions. Il n'y a rien de mal avec débogage de code non valide dans le communiqué. En outre, il est la plupart du temps.
- Même si cette question est assez vieux et a déjà été répondu, je suis intrigué par votre commentaire. Pourriez-vous fournir ou point à un exemple où le code de débogage peut-être pas valide dans des versions release? Je vous remercie beaucoup.
InformationsquelleAutor Xeor
8

Vous pouvez mettre tous vos debug appel à une fonction, laisser l'appeler printf_debug et de mettre le DEBUG l'intérieur de cette fonction.
Le compilateur d'optimiser la fonction vide.
- Merci, santé mentale au dernier .. sauf surtout le travail du préprocesseur.
- Dans ce cas, vous pouvez simplement appeler votre fonction printd
- Qui ne désactivez pas l'évaluation des arguments et de ne pas désactiver l'obligation pour les arguments pour être valide (comme, a déclaré, par exemple). En d'autres termes, il ne veut pas faire ce qui était demandé.
- si n'importe quel type de lien à l'optimisation du temps est fait, le compilateur va inline vide de fonctions et de supprimer du code mort pour l'évaluation des arguments.
- Le problème est qu'il ne sera tout simplement pas compiler si les arguments ne sont pas valides dans libération contexte. Il ne sera pas à "l'optimisation".
InformationsquelleAutor slurdge
5

Sur certains compilateurs (y compris MS VS2010) cela fonctionne,
```
#define CMT / ## /
```
mais pas les bénéficiaires de subventions pour tous les compilateurs.

InformationsquelleAutor Igor Barbarian
2

La norme est d'utiliser
```
#ifndef DEBUG
    #define printd(fmt, ...)  do { } while(0)
#else
    #define printd(fmt, ...) printf(fmt, __VA_ARGS__)
#endif
```
De cette façon, lorsque vous ajoutez un point-virgule à la fin, il fait ce que vous voulez.
Comme il n'y a pas d'opération le compilateur compile le "do...while"

InformationsquelleAutor Dipstick
1

Non testé:
Edit: Testé, en utilisant par moi-même maintenant 🙂
```
#define DEBUG 1
#define printd(fmt,...) if(DEBUG)printf(fmt, __VA_ARGS__)
```
vous oblige non seulement à définir DEBUG mais aussi lui donner un non-zer0 valeur.

Annexe:
Fonctionne aussi bien avec les std::cout

InformationsquelleAutor drahnr
1

En C++17 j'aime utiliser constexpr quelque chose comme ceci
```
#ifndef NDEBUG
constexpr bool DEBUG = true;
#else
constexpr bool DEBUG = false;
#endif
```
Ensuite, vous pouvez faire
```
if constexpr (DEBUG) /* debug code */
```
Les mises en garde sont que, contrairement à une macro du préprocesseur, vous êtes limité dans sa portée. Vous ne pouvez pas déclarer des variables dans un debug conditionnelle qui sont accessibles à partir d'un autre, ni être utilisés à l'extérieur de la fonction étendues.
- Ce n'est pas une réponse, la question est marqué C, et la réponse est pour le C++. Ceux sont deux langues différentes.
InformationsquelleAutor Jesse Maurais
0

Comme indiqué par McKay, vous allez courir dans des problèmes si vous essayez simplement de remplacer printd avec //. Au lieu de cela, vous pouvez utiliser variadric macros pour remplacer printd avec une fonction qui ne fait rien comme dans l'exemple suivant.
```
#ifndef DEBUG
    #define printd(...) do_nothing()
#else
    #define printd(...) printf(__VA_ARGS__)
#endif

void do_nothing() { ; }
```
À l'aide d'un débogueur comme GDB peut aider aussi, mais parfois un rapide printf est assez.

InformationsquelleAutor Swiss
0

J'utilise cette construction beaucoup:
```
#define DEBUG 1
#if DEBUG
#if PROG1
#define DEBUGSTR(msg...)        { printf("P1: "); printf( msg); }
#else
#define DEBUGSTR(msg...)        { printf("P2: "); printf( msg); }
#endif
#else
#define DEBUGSTR(msg...)    ((void) 0)
#endif
```
De cette façon, je peux dire que dans ma console qui programme est de donner quel message d'erreur... aussi, je peux rechercher facilement pour mes messages d'erreur...

Personnellement, je n'aime pas #définissant simplement une partie d'une expression...

InformationsquelleAutor Brian Postow
0

Il a été fait. Je ne le recommande pas. Pas le temps de tester, mais le mécanisme est un peu comme ceci:
```
 #define printd_CAT(x) x ## x
 #ifndef DEBUG
    #define printd printd_CAT(/)
 #else
    #define printd printf
 #endif
```
Cela fonctionne si votre compilateur processus //d'observations dans le compilateur lui-même (il n'y a aucune garantie comme la norme ANSI garantir qu'il y a deux passes pour /* commentaires).

InformationsquelleAutor Joshua
0

Vous pouvez prendre avantage de if. Par exemple,
```
#ifdef debug
    #define printd printf
#else 
    #define printd if (false) printf
#endif
```
Compilateur va supprimer ces code inaccessible si vous définissez une option d'optimisation comme -O2. Cette technique est également utile pour std::cout.

InformationsquelleAutor Ricky Hsu

Vous devez vous connecter pour publier un commentaire.