C / C ++: как использовать do-while (0); построить без предупреждений компилятора, например C4127?

Описание: Это предупреждение (C4127) в данном конкретном случае является тонкой ошибкой компилятора. Не стесняйтесь отключать его.

Глубоко:

Он был предназначен для обнаружения ситуаций, когда логическое выражение оценивается как константа в неочевидных ситуациях (например, if(a==a && a!=a), и каким-то образом это превратило while(true) и другие полезные конструкции в недопустимые.

Microsoft рекомендует использовать for(;;) для бесконечного цикла, если вы хотите, чтобы это предупреждение было включено, и для вашего случая нет решения. Это одно из очень немногих предупреждений четвертого уровня, которые моя компания разрешает отключать.

Возможно, вашему коду требуется больше сов :

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

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

Как отметил Майкл Берр в Carl Smotricz 'answer, для Visual Studio 2008+ можно использовать __ pragma:

#define MYMACRO(f,g)              \
  __pragma(warning(push))         \
  __pragma(warning(disable:4127)) \
  do { f; g; } while (0)          \
  __pragma(warning(pop))

Вы можете поместить его в одну строку (без \s), если хотите, чтобы макросы были нечитаемыми.

У меня есть шаблон, который я основал на ответе здесь, и он работает на clang, gcc и MSVC. Я публикую его здесь в надежде, что он будет полезен другим, и потому что ответы здесь помогли мне его сформулировать.

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

А я использую это так:

do {
   // Some stuff
} ONCE;

Вы также можете использовать это в макросах:

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

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

Это также работает для случая, указанного выше, если F использует ONCE в функции:

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

Изменить: Спустя годы я понимаю, что забыл добавить шаблон, для которого на самом деле написал этот макрос - шаблон "switch-like-a-goto":

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;

Это дает вам конструкцию try / finally-ish, которая более структурирована, чем грубый переход к вашему коду очистки и возврата. Использование этого макроса ONCE вместо while (0) закрывает VS.

Используя более новые версии компилятора MS, вы можете использовать подавление предупреждений:

#define MY_MACRO(stuff) \
    do { \
        stuff \
    __pragma(warning(suppress:4127)) \
    } while(0)

Вы также можете нажать / отключить / нажать, но подавление - гораздо более удобный механизм.

Эта ошибка компилятора была исправлена ​​в Visual Studio 2015 с обновлением 1, даже если примечания к выпуску не упоминают об этом.

Однако ошибка была объяснена в одном из предыдущих ответов:

Описание: Это предупреждение (C4127) в данном конкретном случае является тонкой ошибкой компилятора. Не стесняйтесь отключать его.

Он был предназначен для обнаружения ситуаций, когда логическое выражение оценивается как константа в неочевидных ситуациях (например, if (a == a && a! = A), и каким-то образом оно превратило while (true) и другие полезные конструкции в недопустимые .

Вот еще один возможный подход, который позволяет избежать C4127, C4548 и C6319 (предупреждение анализа кода VS2013) и не требует макросов или прагм:

static const struct {
    inline operator bool() const { return false; }
} false_value;

do {
    // ...
} while (false_value);

Это оптимизирует и компилируется без предупреждений в GCC 4.9.2 и VS2013. На практике это может быть пространство имен.

Предупреждение связано с while(false). На этом сайте приведен пример решения этой проблемы. проблема. Пример с сайта (вам придется переделать его для своего кода):

#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  

Просто вставьте свой код между BEGIN и END.

Ты можешь использовать

do {
    // Anything you like
} WHILE_FALSE;

А ранее определите макрос WHILE_FALSE следующим образом:

#define WHILE_FALSE \
    __pragma(warning(push))         \
    __pragma(warning(disable:4127)) \
    while(false)                    \
  __pragma(warning(pop))

Проверено на MSVC ++ 2013.

Эта штука «while (0)» - хакерская штука, которая только что повернулась, чтобы вас укусить.

Ваш компилятор предлагает #pragmas для выборочного и локального отключения определенных сообщений об ошибках? Если так, это может быть разумной альтернативой.

Вы можете использовать оператор запятой вместо конструкции do-while (0) для макроса с несколькими операторами, который будет использоваться в выражениях. Так что вместо:

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

Использовать:

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

Это работает независимо от платформы и позволяет избежать предупреждения компилятора (даже если выбран самый высокий уровень предупреждения). Обратите внимание, что в запятой, содержащей макрос (второй FOO), результат последнего оператора (Statement3) будет результатом всего макроса.

Должен сказать, я никогда не беспокоился о конструкции do.. while в макросах. Весь код в моих макросах заключен в фигурные скобки, но без do - .. while. Например:

#define F(x) \
    {           \
        x++;    \
    }           \

int main() {
    int a = 1;
    F(a);
    printf( "%d\n", a );
}

Кроме того, мой собственный стандарт кодирования (и неформальная практика в течение многих лет) заключался в том, чтобы все блоки, где бы они ни происходили, были заключены в фигурные скобки, что также более или менее устраняет проблему.

Решение есть, но оно добавит больше циклов в ваш код. Не используйте явное значение в условии while.

Сделать это можно так:

file1.h

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

переменная I_am_a_zero должна быть определена в каком-нибудь .c файле.

В любом случае это предупреждение не отображается в GCC :)

См. Этот связанный с этим вопрос.

Вы можете использовать #pragma warning, чтобы:

1. спасти государство
2. отключить предупреждение
3. напишите оскорбительный код
4. вернуть предупреждение в их предыдущее состояние

(вам нужен # перед прагмами, но SO трудно справиться с ними и форматировать одновременно)

#pragma warning( push )
#pragma warning( disable: 4127 )
// Your code
#pragma warning( pop ) 

Вы хотите нажимать / выдавать предупреждения, а не отключать / включать, потому что вы не хотите вмешиваться в аргументы командной строки, которые могут быть выбраны для включения / выключения предупреждений (кто-то может использовать командную строку, чтобы отключить предупреждение, вы делаете не хочу снова его включать ... код выше имеет дело с этим).

Это лучше, чем глобальное отключение предупреждения, поскольку вы можете контролировать его только для той части, которая вам нужна. Также вы можете сделать его частью макроса.

Что ж, для меня без предупреждения C4127 работает следующее:

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

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

Конечно, компиляторы умны и zzsome не должно быть постоянным

Это отключит предупреждение, и компилятор по-прежнему сможет оптимизировать код:

static inline bool to_bool(const bool v) { return v; }

if (to_bool(0)) { // no warning here
    dead_code(); // will be compiled out (by most compilers)
}

do { something(); } while(to_bool(0)); // no extra code generated

Я нашел, что это самая короткая версия

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

Не проверял, оптимизирован ли он компилятором, но я предполагаю, что это так.

Вы можете использовать цикл for как:

for (;;) {
  // code
  break;
}

Макро:

#define BEGIN \
  for (;;) {

#define END \
  break; }

Я бы использовал

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

}

Это эквивалентно

do
{
}while(0);

и не дает никаких предупреждений.

Используйте переключатель компилятора / wd "4127", чтобы отключить это предупреждение в своем проекте.