Essa função C sempre deve retornar false, mas não

Eu me deparei com uma pergunta interessante em um fórum há muito tempo e quero saber a resposta.

Considere a seguinte função C:

f1.c

#include <stdbool.h>

bool f1()
{
    int var1 = 1000;
    int var2 = 2000;
    int var3 = var1 + var2;
    return (var3 == 0) ? true : false;
}

Isso sempre deve retornar false desde então var3 == 3000. A mainfunção fica assim:

main.c

#include <stdio.h>
#include <stdbool.h>

int main()
{
    printf( f1() == true ? "true\n" : "false\n");
    if( f1() )
    {
        printf("executed\n");
    }
    return 0;
}

Como f1()sempre deve retornar false, seria de esperar que o programa imprimisse apenas um falso na tela. Mas depois de compilá-lo e executá-lo, executado também é exibido:

$ gcc main.c f1.c -o test
$ ./test
false
executed

Por que é que? Esse código tem algum tipo de comportamento indefinido?

Nota: Eu compilei com gcc (Ubuntu 4.9.2-10ubuntu13) 4.9.2.

Conforme observado em outras respostas, o problema é que você usa gcc sem opções de compilador definidas. Se você fizer isso, o padrão será o que é chamado "gnu90", que é uma implementação não padrão do antigo padrão C90 retirado de 1990.

No antigo padrão C90, havia uma falha importante na linguagem C: se você não declarasse um protótipo antes de usar uma função, o padrão seria int func ()(onde ( )significa "aceitar qualquer parâmetro"). Isso altera a convenção de chamada da função func, mas não altera a definição real da função. Como o tamanho boole o tamanho intsão diferentes, seu código chama um comportamento indefinido quando a função é chamada.

Esse perigoso comportamento sem sentido foi corrigido no ano de 1999, com o lançamento do padrão C99. Declarações implícitas de funções foram banidas.

Infelizmente, o GCC até a versão 5.xx ainda usa o padrão C antigo por padrão. Provavelmente, não há razão para você querer compilar seu código como algo que não seja o padrão C. Portanto, você deve dizer explicitamente ao GCC que ele deve compilar seu código como código C moderno, em vez de porcaria GNU não padrão de 25 anos ou mais .

Corrija o problema sempre compilando seu programa como:

gcc -std=c11 -pedantic-errors -Wall -Wextra

• -std=c11 diz para fazer uma tentativa tímida de compilar de acordo com o padrão C (atual) (informalmente conhecido como C11).
• -pedantic-errors diz para ele fazer de todo o coração o descrito acima e fornecer erros do compilador quando você escreve um código incorreto que viola o padrão C.
• -Wall significa dar-me alguns avisos extras que podem ser bons.
• -Wextra significa dar-me outros avisos extras que podem ser bons.

Você não tem um protótipo declarado f1()em main.c, portanto ele é implicitamente definido como int f1(), o que significa que é uma função que pega um número desconhecido de argumentos e retorna um int.

Se inte tiver booltamanhos diferentes, isso resultará em um comportamento indefinido . Por exemplo, na minha máquina, inttem 4 bytes e boolum byte. Como a função está definida para retornar bool, ela coloca um byte na pilha quando retorna. No entanto, como é declarado implicitamente para retornar intdo main.c, a função de chamada tentará ler 4 bytes da pilha.

As opções padrão dos compiladores no gcc não indicam que ele está fazendo isso. Mas se você compilar -Wall -Wextra, obterá o seguinte:

main.c: In function ‘main’:
main.c:6: warning: implicit declaration of function ‘f1’

Para corrigir isso, adicione uma declaração para f1em main.c, antes main:

bool f1(void);

Observe que a lista de argumentos está explicitamente definida como void, o que informa ao compilador que a função não aceita argumentos, em oposição a uma lista de parâmetros vazia, o que significa um número desconhecido de argumentos. A definição f1em f1.c também deve ser alterada para refletir isso.

Acho interessante ver onde realmente ocorre a diferença de tamanho mencionada na excelente resposta de Lundin.

Se você compilar --save-temps, obterá arquivos de montagem que podem ser vistos. Aqui está a parte onde f1()faz a == 0comparação e retorna seu valor:

cmpl    $0, -4(%rbp)
sete    %al

A parte retornada é sete %al. Nas convenções de chamada x86 de C, retornam valores de 4 bytes ou menos (que incluem inte bool) são retornados via registrador %eax. %alé o byte mais baixo de %eax. Portanto, os 3 bytes superiores de %eaxsão deixados em um estado não controlado.

Agora em main():

call    f1
testl   %eax, %eax
je  .L2

Este verifica se o conjunto de %eaxé zero, porque acha que está testando um int.

A adição de uma declaração de função explícita muda main()para:

call    f1
testb   %al, %al
je  .L2

que é o que queremos.

Por favor compile com um comando como este:

gcc -Wall -Wextra -Werror -std=gnu99 -o main.exe main.c

Resultado:

main.c: In function 'main':
main.c:14:5: error: implicit declaration of function 'f1' [-Werror=impl
icit-function-declaration]
     printf( f1() == true ? "true\n" : "false\n");
     ^
cc1.exe: all warnings being treated as errors

Com essa mensagem, você deve saber o que fazer para corrigi-la.

Edit: Depois de ler um comentário (agora excluído), tentei compilar seu código sem os sinalizadores. Bem, isso me levou a erros do vinculador sem avisos do compilador, em vez de erros do compilador. E esses erros de vinculação são mais difíceis de entender; portanto, mesmo que -std-gnu99não seja necessário, tente sempre usar pelo menos -Wall -Werrorisso poupará muita dor na bunda.