C/C++: Comment utiliser le do-while(0); construire sans les avertissements du compilateur comme C4127?

Peut-être que votre code doit plus chouettes:

do { stuff(); } while (0,0)

Ou les moins photogéniques, mais aussi moins d'avertissement de production:

do { stuff(); } while ((void)0,0)

J'ai un modèle que j'ai basé sur une réponse ici & il fonctionne sur clang, gcc & MSVC. Je poste ici dans l'espoir qu'il sera utile pour les autres & parce que les réponses ici m'a aidé à formuler.

#ifdef WIN32
#  define ONCE __pragma( warning(push) ) \
               __pragma( warning(disable:4127) ) \
               while( 0 ) \
               __pragma( warning(pop) )
#else
#  define ONCE while( 0 )
#endif

Et je l'utilise comme ceci:

do {
   //Some stuff
} ONCE;

Vous pouvez l'utiliser dans les macros trop:

void SomeLogImpl( const char* filename, int line, ... );    

#ifdef NDEBUG
#  define LOG( ... )
#else
#  define LOG( ... ) do { \
      SomeLogImpl( __FILE__, __LINE__, __VA_ARGS__ ); \
   } ONCE
#endif

Cela fonctionne aussi pour le cas indiqué ci-dessus, si F utilise 'une FOIS' dans une fonction:

#define F( x ) do { f(x); } ONCE
...
if (a==b) F(bar); else someFunc();

---

Edit: des Années plus tard, je me rends compte que j'ai oublié d'ajouter le modèle que j'ai réellement écrit cette macro pour - le "switch-comme-un-rendez-vous" modèle:

do {
    begin_some_operation();

    if( something_is_wrong ) {
        break;
    }

    continue_big_operation();

    if( another_failure_cond ) {
        break;
    }

    finish_big_operation();
    return SUCCESS;
} ONCE;

cleanup_the_mess();
return FAILURE;

Cela vous donne un try/finally-ish construction qui est plus structuré qu'un crufty goto à votre nettoyage & code de retour. En utilisant cette FOIS la macro au lieu de tout(0) s'VS en place.

Ce compilateur bug a été corrigé dans Visual Studio 2015 mise à Jour de 1, même si le releases notes ne le mentionnez pas.

Le bug a été expliqué dans l'une des précédentes réponses si:

Résumé: Cet avertissement (C4127) dans ce cas particulier, est un subtil compilateur bug. Hésitez pas à le désactiver.

Il a pour but de repérer les situations lors de la logique de l'expression prend la valeur d'une constante dans la non-évidence de situations (telles que, si(a==a && a!=a), et d'une certaine façon, il s'est tourné while(true) et d'autres constructions dans invalide.

L'avertissement est due à la while(false). Cette site donne un exemple de la façon de contourner ce problème. Exemple de site (vous devrez à nouveau travailler pour votre code):

#define MULTI_LINE_MACRO_BEGIN do {  
#define MULTI_LINE_MACRO_END \  
    __pragma(warning(push)) \  
    __pragma(warning(disable:4127)) \  
    } while(0) \  
    __pragma(warning(pop))

#define MULTI_LINE_MACRO \  
        MULTI_LINE_MACRO_BEGIN \  
            std::printf("Hello "); \  
            std::printf("world!\n"); \  
        MULTI_LINE_MACRO_END  

Il suffit d'insérer votre code entre le début et la FIN.

Cette "while(0)" s'étoffe d'un hack et vient de tourner autour de vous mordre.

Est-ce que votre compilateur offre #pragmas sélective et localement la désactivation des messages d'erreur? Si oui, ce pourrait être une bonne alternative.

Vous pouvez utiliser l'opérateur virgule au lieu de do-while(0) construire pour le multi-déclaration de macro pour être utilisées dans les expressions. Ainsi, au lieu de:

#define FOO(...)    do { Statement1; Statement2; Statement3; } while(0)

Utilisation:

#define FOO(...)    (Statement1, Statement2, Statement3)

Cela fonctionne de manière indépendante de la plate-forme et permet d'éviter d'avertissement du compilateur (même si plus haut niveau d'avertissement est activée).
Notez que dans virgules contenant la macro (deuxième FOO) le résultat de la dernière instruction (Statement3) serait le résultat de la macro.

Il y a une solution, mais il va ajouter plus de cycles à votre code. N'utilisez pas de valeur explicite dans la condition du while.

Vous pouvez le faire comme ceci:

fichier1.h

extern const int I_am_a_zero;
#define MY_MACRO(foo,bar) \
do \
{ \
} \
while(I_am_a_zero);

la variable I_am_a_zero devraient être définies dans certains .c fichier.

De toute façon cet avertissement ne s'affiche pas dans GCC 🙂

Voir ce une question relative à la.

Bien, pour moi, les ouvrages suivants, sans le C4127 avertissement:

#define ALWAYS_TRUE(zzsome) ((##zzsome)==(##zzsome))

void foo()
{
    int a = 0;
    while( ALWAYS_TRUE(a) )
    {
    }
}

Bien sûr, les compilateurs sont intelligents et zzsome ne devrait pas être une constante

J'ai trouvé ceci pour être la version la plus courte

do {
  //... 
}
while (([]() { return 0; })())  /* workaround for MSVC warning C4172 : conditional expression is constant */

N'ai pas vérifié pour voir si il est optimisé par le compilateur, mais je suppose qu'il est.

J'utiliserais

for(int i = 0; i < 1; ++i) //do once
{

}

C'est l'équivalent de

do
{
}while(0);

et rendements pas de mises en garde.