Por que printf (“% f”, 0); dar comportamento indefinido?

A declaração

printf("%f\n",0.0f);

imprime 0.

No entanto, a declaração

printf("%f\n",0);

imprime valores aleatórios.

Percebo que estou exibindo algum tipo de comportamento indefinido, mas não consigo descobrir o porquê especificamente.

Um valor de ponto flutuante em que todos os bits são 0 ainda é válido floatcom valor de 0.
floate inttêm o mesmo tamanho na minha máquina (se isso for relevante).

Por que usar um literal inteiro em vez de um literal de ponto flutuante printfcausa esse comportamento?

PS o mesmo comportamento pode ser visto se eu usar

int i = 0;
printf("%f\n", i);

O "%f"formato requer um argumento do tipo double. Você está dando a ele um argumento do tipo int. É por isso que o comportamento é indefinido.

O padrão não garante que todos os bits zero sejam uma representação válida de 0.0(embora muitas vezes seja), ou de qualquer doublevalor, ou que inte doublesejam do mesmo tamanho (lembre-se de que doublenão é float), ou, mesmo que sejam iguais tamanho, que eles são passados ​​como argumentos para uma função variável da mesma maneira.

Pode acontecer de "funcionar" em seu sistema. Esse é o pior sintoma possível de comportamento indefinido, porque torna difícil diagnosticar o erro.

N1570 7.21.6.1 parágrafo 9:

... Se algum argumento não for do tipo correto para a especificação de conversão correspondente, o comportamento é indefinido.

Argumentos do tipo floatsão promovidos a double, e é por isso que printf("%f\n",0.0f)funciona. Argumentos de tipos inteiros mais estreitos do que intos promovidos para intou para unsigned int. Estas regras de promoção (especificadas por N1570 6.5.2.2 parágrafo 6) não ajudam no caso de printf("%f\n", 0).

Observe que se você passar uma constante 0para uma função não variada que espera um doubleargumento, o comportamento é bem definido, assumindo que o protótipo da função esteja visível. Por exemplo, sqrt(0)(after #include <math.h>) converte implicitamente o argumento 0de intpara double- porque o compilador pode ver pela declaração de sqrtque ele espera um doubleargumento. Não tem essa informação para printf. Funções variáveis ​​como printfsão especiais e requerem mais cuidado ao escrever chamadas para elas.

Primeiro, como tocou em várias outras respostas, mas não, na minha opinião, enunciado de forma suficientemente clara: Ele faz o trabalho para fornecer um número inteiro na maioria dos contextos em que uma função de biblioteca tem um doubleou floatargumento. O compilador irá inserir automaticamente uma conversão. Por exemplo, sqrt(0)é bem definido e se comportará exatamente como sqrt((double)0), e o mesmo é verdadeiro para qualquer outra expressão do tipo inteiro usada lá.

printfé diferente. É diferente porque leva um número variável de argumentos. Seu protótipo de função é

extern int printf(const char *fmt, ...);

Portanto, quando você escreve

printf(message, 0);

o compilador não tem nenhuma informação sobre que tipo printf espera que o segundo argumento seja. Ele tem apenas o tipo da expressão do argumento, ou seja int, para seguir. Portanto, ao contrário da maioria das funções de biblioteca, cabe a você, o programador, garantir que a lista de argumentos corresponda às expectativas da string de formato.

(Compiladores modernos podem olhar para uma string de formato e dizer que você tem uma incompatibilidade de tipo, mas eles não vão começar a inserir conversões para realizar o que você pretendia, porque melhor seu código deve quebrar agora, quando você perceber , do que anos depois, quando reconstruído com um compilador menos útil.)

Agora, a outra metade da pergunta era: Dado que (int) 0 e (float) 0,0 são, na maioria dos sistemas modernos, ambos representados como 32 bits, todos sendo zero, por que não funciona mesmo assim, por acidente? O padrão C diz apenas "isso não é necessário para funcionar, você está sozinho", mas deixe-me explicar os dois motivos mais comuns pelos quais não funcionaria; isso provavelmente ajudará você a entender por que não é obrigatório.

Primeiro, por razões históricas, quando você passa um floatpor uma lista de argumentos de variável, ele é promovido para double, que, na maioria dos sistemas modernos, tem 64 bits de largura. Portanto, printf("%f", 0)passa apenas 32 bits zero para um receptor que espera 64 deles.

A segunda razão, igualmente significativa, é que os argumentos da função de ponto flutuante podem ser passados ​​em um lugar diferente dos argumentos inteiros. Por exemplo, a maioria das CPUs tem arquivos de registro separados para valores inteiros e de ponto flutuante, então pode ser uma regra que os argumentos de 0 a 4 vão nos registros r0 a r4 se forem inteiros, mas f0 a f4 se forem de ponto flutuante. Portanto, printf("%f", 0)procura no registro f1 por esse zero, mas ele não está lá.

Normalmente, quando você chama uma função que espera um double, mas você fornece um int, o compilador será automaticamente convertido em a doublepara você. Isso não acontece com o printf, porque os tipos dos argumentos não são especificados no protótipo da função - o compilador não sabe que uma conversão deve ser aplicada.

Por que usar um literal inteiro em vez de um literal flutuante causa esse comportamento?

Porque printf()não tem parâmetros digitados além doconst char* formatstring do primeiro. Ele usa reticências ( ...) no estilo c para todo o resto.

Ele apenas decide como interpretar os valores passados ​​de acordo com os tipos de formatação fornecidos na string de formato.

Você teria o mesmo tipo de comportamento indefinido de quando tenta

 int i = 0;
 const double* pf = (const double*)(&i);
 printf("%f\n",*pf); // dereferencing the pointer is UB

Usar um printf()especificador "%f"e tipo (int) 0incompatíveis leva a um comportamento indefinido.

Se uma especificação de conversão for inválida, o comportamento é indefinido. C11dr §7.21.6.1 9

Causas candidatas de UB.

1. É UB por especificação e a compilação é complicada - disse nuf.

2. doublee intsão de tamanhos diferentes.

3. doublee intpode passar seus valores usando diferentes pilhas (geral vs. pilha FPU ).

4. A double 0.0 pode não ser definido por um padrão de bits totalmente zero. (raro)

Esta é uma daquelas grandes oportunidades de aprender com os avisos do compilador.

$ gcc -Wall -Wextra -pedantic fnord.c 
fnord.c: In function ‘main’:
fnord.c:8:2: warning: format ‘%f’ expects argument of type ‘double’, but argument 2 has type ‘int’ [-Wformat=]
  printf("%f\n",0);
  ^

ou

$ clang -Weverything -pedantic fnord.c 
fnord.c:8:16: warning: format specifies type 'double' but the argument has type 'int' [-Wformat]
        printf("%f\n",0);
                ~~    ^
                %d
1 warning generated.

Então, printfestá produzindo um comportamento indefinido porque você está passando um tipo de argumento incompatível.

Não tenho certeza do que é confuso.

Sua string de formato espera um double; em vez disso, você fornece um int.

Se os dois tipos têm a mesma largura de bits é totalmente irrelevante, exceto que pode ajudá-lo a evitar a obtenção de exceções de violação de memória física de código quebrado como este.

"%f\n"garante resultado previsível apenas quando o segundo printf()parâmetro tem tipo de double. Em seguida, argumentos extras de funções variáveis ​​estão sujeitos à promoção de argumento padrão. Argumentos inteiros se enquadram na promoção de inteiros, que nunca resulta em valores digitados de ponto flutuante. E os floatparâmetros são promovidos paradouble .

Para completar: standard permite que o segundo argumento seja ou floatou doublee nada mais.

Por que é formalmente UB já foi discutido em várias respostas.

O motivo pelo qual você obtém especificamente esse comportamento depende da plataforma, mas provavelmente é o seguinte:

• printfespera seus argumentos de acordo com a propagação padrão de vararg. Isso significa que um floatserá um doublee qualquer coisa menor que um intserá umint .
• Você está passando um intonde a função espera um double. O seu inté provavelmente de 32 bits, o seu double64 bit. Isso significa que os quatro bytes da pilha começando no lugar onde o argumento deveria estar 0, mas os quatro bytes seguintes têm conteúdo arbitrário. Isso é o que é usado para construir o valor que é exibido.

A principal causa deste problema de "valor indeterminado" está no elenco do ponteiro no intvalor passado para a printfseção de parâmetros da variável para um ponteiro nos doubletipos queva_arg macro executa.

Isso faz com que uma referência a uma área de memória que não foi completamente inicializada com o valor passado como parâmetro para o printf, porque o doubletamanho da área do buffer de memória é maior queint tamanho.

Portanto, quando este ponteiro é desreferenciado, ele retorna um valor indeterminado, ou melhor, um "valor" que contém em parte o valor passado como parâmetro para printf, e o restante pode vir de outra área de buffer de pilha ou mesmo de uma área de código ( levantando uma exceção de falha de memória), um estouro de buffer real .


Ele pode considerar essas partes específicas de implementações de código semplificado de "printf" e "va_arg" ...

printf

va_list arg;
....
case('%f')
      va_arg ( arg, double ); //va_arg is a macro, and so you can pass it the "type" that will be used for casting the int pointer argument of printf..
.... 

a implementação real em vprintf (considerando gnu impl.) de gerenciamento de caso de código de parâmetros de valor duplo é:

if (__ldbl_is_dbl)
{
   args_value[cnt].pa_double = va_arg (ap_save, double);
   ...
}

va_arg

char *p = (double *) &arg + sizeof arg;  //printf parameters area pointer

double i2 = *((double *)p); //casting to double because va_arg(arg, double)
   p += sizeof (double);

referências

1. implementação glibc do projeto gnu de "printf" (vprintf))
2. exemplo de código de semplificação de printf
3. exemplo de código de semplificação de va_arg