Por que usar instruções do-while e if-else aparentemente sem sentido nas macros?

Em muitas macros C / C ++, estou vendo o código da macro envolvido no que parece ser um do whileloop sem sentido . Aqui estão alguns exemplos.

#define FOO(X) do { f(X); g(X); } while (0)
#define FOO(X) if (1) { f(X); g(X); } else

Não consigo ver o que do whileestá fazendo. Por que não escrever isso sem ele?

#define FOO(X) f(X); g(X)

O do ... whilee if ... elseexiste para que um ponto-e-vírgula após a macro sempre signifique a mesma coisa. Digamos que você tenha algo parecido com a sua segunda macro.

#define BAR(X) f(x); g(x)

Agora, se você usar BAR(X);em uma if ... elsedeclaração, onde os corpos da declaração if não estiverem entre colchetes, você terá uma surpresa ruim.

if (corge)
  BAR(corge);
else
  gralt();

O código acima seria expandido para

if (corge)
  f(corge); g(corge);
else
  gralt();

que é sintaticamente incorreto, pois o resto não está mais associado ao if. Não ajuda a agrupar as coisas entre chaves na macro, porque um ponto-e-vírgula após as chaves é sintaticamente incorreto.

if (corge)
  {f(corge); g(corge);};
else
  gralt();

Existem duas maneiras de corrigir o problema. O primeiro é usar uma vírgula para sequenciar as instruções dentro da macro sem roubar sua capacidade de agir como uma expressão.

#define BAR(X) f(X), g(X)

A versão acima da barra BARexpande o código acima para o que segue, que é sintaticamente correto.

if (corge)
  f(corge), g(corge);
else
  gralt();

Isso não funciona se, em vez de f(X)você possuir um corpo de código mais complicado que precisar ser inserido em seu próprio bloco, digamos, por exemplo, para declarar variáveis ​​locais. No caso mais geral, a solução é usar algo como do ... whilefazer com que a macro seja uma única declaração que leva um ponto-e-vírgula sem confusão.

#define BAR(X) do { \
  int i = f(X); \
  if (i > 4) g(i); \
} while (0)

Você não precisa usá- do ... whilelo, também pode criar algo if ... else, embora, quando se if ... elseexpanda dentro de um if ... else, leve a um " dangling else ", o que poderia tornar um problema de dangling else existente ainda mais difícil de encontrar, como no código a seguir .

if (corge)
  if (1) { f(corge); g(corge); } else;
else
  gralt();

O ponto é usar o ponto e vírgula em contextos em que um ponto e vírgula oscilante é incorreto. Certamente, poderia (e provavelmente deveria) argumentar-se neste ponto que seria melhor declarar BARcomo uma função real, não como uma macro.

Em resumo, do ... whileexiste para solucionar as deficiências do pré-processador C. Quando esses guias de estilo C dizem para você demitir o pré-processador C, esse é o tipo de coisa com a qual eles estão preocupados.

Macros são partes de texto copiadas / coladas que o pré-processador colocará no código original; o autor da macro espera que a substituição produza código válido.

Existem três boas "dicas" para ter sucesso nisso:

Ajude a macro a se comportar como código genuíno

O código normal geralmente termina com um ponto e vírgula. O usuário deve visualizar o código sem precisar de um ...

doSomething(1) ;
DO_SOMETHING_ELSE(2)  // <== Hey? What's this?
doSomethingElseAgain(3) ;

Isso significa que o usuário espera que o compilador produza um erro se o ponto e vírgula estiver ausente.

Mas o verdadeiro motivo realmente bom é que, em algum momento, o autor da macro talvez precise substituir a macro por uma função genuína (talvez embutida). Portanto, a macro deve realmente se comportar como uma.

Portanto, devemos ter uma macro precisando de ponto e vírgula.

Produzir um código válido

Como mostrado na resposta do jfm3, às vezes a macro contém mais de uma instrução. E se a macro for usada dentro de uma instrução if, isso será problemático:

if(bIsOk)
   MY_MACRO(42) ;

Essa macro pode ser expandida como:

#define MY_MACRO(x) f(x) ; g(x)

if(bIsOk)
   f(42) ; g(42) ; // was MY_MACRO(42) ;

A gfunção será executada independentemente do valor de bIsOk.

Isso significa que precisamos adicionar um escopo à macro:

#define MY_MACRO(x) { f(x) ; g(x) ; }

if(bIsOk)
   { f(42) ; g(42) ; } ; // was MY_MACRO(42) ;

Produzir um código válido 2

Se a macro é algo como:

#define MY_MACRO(x) int i = x + 1 ; f(i) ;

Podemos ter outro problema no seguinte código:

void doSomething()
{
    int i = 25 ;
    MY_MACRO(32) ;
}

Porque expandiria como:

void doSomething()
{
    int i = 25 ;
    int i = 32 + 1 ; f(i) ; ; // was MY_MACRO(32) ;
}

Esse código não será compilado, é claro. Então, novamente, a solução está usando um escopo:

#define MY_MACRO(x) { int i = x + 1 ; f(i) ; }

void doSomething()
{
    int i = 25 ;
    { int i = 32 + 1 ; f(i) ; } ; // was MY_MACRO(32) ;
}

O código se comporta corretamente novamente.

Combinando ponto-e-vírgula + efeitos de escopo?

Há um idioma C / C ++ que produz este efeito: O loop do / while:

do
{
    // code
}
while(false) ;

O do / while pode criar um escopo, encapsulando o código da macro, e precisa de um ponto e vírgula no final, expandindo para o código que precisa de um.

O bônus?

O compilador C ++ otimizará o loop do / while, pois o fato de sua pós-condição ser falsa é conhecido no momento da compilação. Isso significa que uma macro como:

#define MY_MACRO(x)                                  \
do                                                   \
{                                                    \
    const int i = x + 1 ;                            \
    f(i) ; g(i) ;                                    \
}                                                    \
while(false)

void doSomething(bool bIsOk)
{
   int i = 25 ;

   if(bIsOk)
      MY_MACRO(42) ;

   // Etc.
}

expandirá corretamente como

void doSomething(bool bIsOk)
{
   int i = 25 ;

   if(bIsOk)
      do
      {
         const int i = 42 + 1 ; // was MY_MACRO(42) ;
         f(i) ; g(i) ;
      }
      while(false) ;

   // Etc.
}

e é então compilado e otimizado como

void doSomething(bool bIsOk)
{
   int i = 25 ;

   if(bIsOk)
   {
      f(43) ; g(43) ;
   }

   // Etc.
}

@ jfm3 - Você tem uma boa resposta para a pergunta. Você também pode adicionar que o idioma da macro também evita o comportamento não intencional possivelmente mais perigoso (porque não há erro) com instruções simples 'se':

#define FOO(x)  f(x); g(x)

if (test) FOO( baz);

expande para:

if (test) f(baz); g(baz);

que é sintaticamente correto, portanto não há erro do compilador, mas tem a conseqüência provavelmente não intencional de que g () sempre será chamado.

As respostas acima explicam o significado dessas construções, mas há uma diferença significativa entre as duas que não foi mencionada. De fato, há uma razão para preferir do ... whileo if ... elseconstruto.

O problema da if ... elseconstrução é que ela não o força a colocar o ponto e vírgula. Como neste código:

FOO(1)
printf("abc");

Embora tenhamos deixado de fora o ponto-e-vírgula (por engano), o código será expandido para

if (1) { f(X); g(X); } else
printf("abc");

e será compilado silenciosamente (embora alguns compiladores possam emitir um aviso para código inacessível). Mas a printfdeclaração nunca será executada.

do ... whileA construção não tem esse problema, pois o único token válido após o while(0)é um ponto e vírgula.

Embora seja esperado que os compiladores otimizem os do { ... } while(false);loops, existe outra solução que não exigiria essa construção. A solução é usar o operador de vírgula:

#define FOO(X) (f(X),g(X))

ou ainda mais exoticamente:

#define FOO(X) g((f(X),(X)))

Embora isso funcione bem com instruções separadas, não funcionará com casos em que variáveis ​​são construídas e usadas como parte do #define:

#define FOO(X) (int s=5,f((X)+s),g((X)+s))

Com isso, seria forçado a usar a construção do / while.

A biblioteca de pré-processadores P99 de Jens Gustedt (sim, o fato de que isso existe também me impressionou !) Melhora a if(1) { ... } elseconstrução de uma maneira pequena, mas significativa, definindo o seguinte:

#define P99_NOP ((void)0)
#define P99_PREFER(...) if (1) { __VA_ARGS__ } else
#define P99_BLOCK(...) P99_PREFER(__VA_ARGS__) P99_NOP

A lógica para isso é que, diferentemente da do { ... } while(0)construção, breake continueainda funciona dentro do bloco especificado, ele ((void)0)cria um erro de sintaxe se o ponto-e-vírgula for omitido após a chamada de macro, que, caso contrário, ignoraria o próximo bloco. (Na verdade, não há um problema "dangling else" aqui, pois ele elsese liga ao mais próximo if, que é o da macro.)

Se você estiver interessado nos tipos de coisas que podem ser feitas com mais ou menos segurança com o pré-processador C, consulte essa biblioteca.

Por algumas razões, não posso comentar a primeira resposta ...

Alguns de vocês mostraram macros com variáveis ​​locais, mas ninguém mencionou que você não pode simplesmente usar qualquer nome em uma macro! Vai morder o usuário algum dia! Por quê? Porque os argumentos de entrada são substituídos no seu modelo de macro. E em seus exemplos de macro, você usa o nome variado provavelmente mais usado, i .

Por exemplo, quando a seguinte macro

#define FOO(X) do { int i; for (i = 0; i < (X); ++i) do_something(i); } while (0)

é usado na seguinte função

void some_func(void) {
    int i;
    for (i = 0; i < 10; ++i)
        FOO(i);
}

a macro não usará a variável pretendida i, declarada no início de some_func, mas a variável local, declarada no loop do ... while da macro.

Portanto, nunca use nomes de variáveis ​​comuns em uma macro!

Explicação

do {} while (0)e if (1) {} elsecertifique-se de que a macro seja expandida para apenas 1 instrução. De outra forma:

if (something)
  FOO(X); 

expandiria para:

if (something)
  f(X); g(X); 

E g(X)seria executado fora da ifinstrução de controle. Isso é evitado ao usar do {} while (0)e if (1) {} else.

Melhor alternativa

Com uma expressão de instrução GNU (não faz parte do padrão C), você tem uma maneira melhor do que do {} while (0)e if (1) {} elseresolvê-lo, simplesmente usando ({}):

#define FOO(X) ({f(X); g(X);})

E essa sintaxe é compatível com valores de retorno (observe que do {} while (0)não é), como em:

return FOO("X");

Eu não acho que foi mencionado, então considere isso

while(i<100)
  FOO(i++);

seria traduzido para

while(i<100)
  do { f(i++); g(i++); } while (0)

observe como i++é avaliado duas vezes pela macro. Isso pode levar a alguns erros interessantes.