O que exatamente um bloco #if 0… #endif faz?

Em C / C ++

O que acontece com o código colocado entre um bloco #if 0/ #endif?

#if 0

//Code goes here

#endif

O código simplesmente é ignorado e, portanto, não é executado?

Não apenas ele não é executado, nem é compilado.

#ifé um comando de pré-processador, que é avaliado antes da etapa de compilação real. O código dentro desse bloco não aparece no binário compilado.

É frequentemente usado para remover temporariamente segmentos de código com a intenção de reativá-los mais tarde.

É idêntico a comentar o bloco, exceto com uma diferença importante: aninhar não é um problema. Considere este código:

foo();
bar(x, y); /* x must not be NULL */
baz();

Se quiser comentar, posso tentar:

/*
foo();
bar(x, y); /* x must not be NULL */
baz();
*/

Bzzt. Erro de sintaxe! Por quê? Como os comentários do bloco não são aninhados e, portanto (como você pode ver no destaque da sintaxe do SO)), */a palavra "NULL" finaliza o comentário, fazendo com que a bazchamada não seja comentada e o erro de sintaxe */após baz. Por outro lado:

#if 0
foo();
bar(x, y); /* x must not be NULL */
baz();
#endif

Trabalha para comentar a coisa toda. E os n #if 0irão se aninhar, assim:

#if 0
pre_foo();
#if 0
foo();
bar(x, y); /* x must not be NULL */
baz();
#endif
quux();
#endif

Embora, claro, isso possa ficar um pouco confuso e se tornar uma dor de cabeça de manutenção, se não for comentado adequadamente.

Ele comenta permanentemente esse código para que o compilador nunca o compile.

Mais tarde, o codificador pode alterar o #ifdef para compilar esse código no programa, se ele quiser.

É exatamente como o código não existe.

O que exatamente um bloco #if 0… #endif faz?

Ele diz que o autor obviamente nunca ouviu falar de um sistema de controle de versão. O que, por sua vez, diz para você fugir o mais longe possível…

Eu gostaria de adicionar para o #else caso:

#if 0
   /* Code here will NOT be complied. */
#else
   /* Code will be compiled. */
#endif


#if 1
   /* Code will be complied. */
#else
   /* Code will NOT be compiled. */
#endif

Quando o pré-processador vê #if, verifica se o próximo token possui um valor diferente de zero. Se isso acontecer, ele mantém o código para o compilador. Caso contrário, ele se livra desse código para que o compilador nunca o veja.

Se alguém disser #if 0, estará efetivamente comentando o código para que nunca seja compilado. Você pode pensar nisso da mesma forma como se eles tivessem colocado / * ... * / em torno dele. Não é exatamente o mesmo, mas tem o mesmo efeito.

Se você quiser entender o que aconteceu em detalhes, pode procurar com frequência. Muitos compiladores permitem ver os arquivos após a execução do pré-processador. Por exemplo, no Visual C ++, o comando switch / P executará o pré-processador e colocará os resultados em um arquivo .i.

Linhas começando com a #são diretivas de pré-processador . #if 0 [...] #endifblocos não chegam ao compilador e não geram código de máquina.

Você pode demonstrar o que acontece com o pré-processador com um arquivo de origem ifdef.cxx:

#if 0
This code will not be compiled
#else
int i = 0;
#endif

Corrida gcc -E ifdef.cxx mostrará o que é compilado.

Você pode optar por usar esse mecanismo para impedir que um bloco de código seja compilado durante o ciclo de desenvolvimento, mas provavelmente não deseja fazer check-in no controle de origem, pois apenas adiciona fragmentos ao código e reduz a legibilidade. Se um comentário histórico foi comentado, ele deve ser removido: o controle de origem contém o histórico, certo?

Além disso, a resposta pode ser a mesma para C e C ++, mas não existe uma linguagem chamada C / C ++ e não é um bom hábito referir-se a essa linguagem.

Não exatamente

int main(void)
{
   #if 0
     the apostrophe ' causes a warning
   #endif
   return 0;
}

Ele mostra "tc: 4: 19: aviso: 'caractere final ausente" com o gcc 4.2.4

É uma maneira barata de comentar, mas suspeito que possa ter um potencial de depuração. Por exemplo, vamos supor que você tenha uma construção que produza valores para um arquivo. Você pode não querer isso em uma versão final para poder usar o #if 0 ... #endif.

Além disso, suspeito que uma maneira melhor de fazê-lo para fins de depuração seria:

#ifdef DEBUG
// output to file
#endif

Você pode fazer algo assim e pode fazer mais sentido e tudo o que você precisa fazer é definir DEBUG para ver os resultados.