¿Por qué printf ("% f", 0); dar un comportamiento indefinido?

La declaración

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

imprime 0.

Sin embargo, la declaración

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

imprime valores aleatorios.

Me doy cuenta de que estoy exhibiendo algún tipo de comportamiento indefinido, pero no puedo entender por qué específicamente.

Un valor de punto flotante en el que todos los bits son 0 sigue siendo válido floatcon un valor de 0
floaty intson del mismo tamaño en mi máquina (si eso es incluso relevante).

¿Por qué el uso de un literal entero en lugar de un literal de punto flotante printfcausa este comportamiento?

PD: se puede ver el mismo comportamiento si uso

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

El "%f"formato requiere un argumento de tipo double. Le está dando un argumento de tipo int. Por eso el comportamiento no está definido.

La norma no garantiza que todos los bits de cero es una representación válida de 0.0(aunque a menudo es), o de cualquier doublevalor, o que inty doubleson del mismo tamaño (recuerda que es double, no float), o, incluso si son de la misma size, que se pasan como argumentos a una función variable de la misma manera.

Puede suceder que "funcione" en su sistema. Ese es el peor síntoma posible de comportamiento indefinido, porque dificulta el diagnóstico del error.

N1570 7.21.6.1 párrafo 9:

... Si algún argumento no es del tipo correcto para la especificación de conversión correspondiente, el comportamiento no está definido.

floatSe promueven argumentos de tipo double, razón por la cual printf("%f\n",0.0f)funciona. Argumentos de tipos enteros más estrechos que los que intse promueven intao a unsigned int. Estas reglas de promoción (especificadas por N1570 6.5.2.2 párrafo 6) no ayudan en el caso de printf("%f\n", 0).

Tenga en cuenta que si pasa una constante 0a una función no variada que espera un doubleargumento, el comportamiento está bien definido, asumiendo que el prototipo de la función es visible. Por ejemplo, sqrt(0)(after #include <math.h>) convierte implícitamente el argumento 0de inta double, porque el compilador puede ver en la declaración sqrtque espera un doubleargumento. No tiene tal información para printf. Las funciones variables como printfson especiales y requieren más cuidado al escribirles las llamadas.

En primer lugar, como tocado en varias otras respuestas, pero no, en mi opinión, explicado con suficiente claridad: Se hace el trabajo para proporcionar un número entero en la mayoría de los contextos en los que una función de biblioteca toma una doubleo floatargumento. El compilador insertará automáticamente una conversión. Por ejemplo, sqrt(0)está bien definido y se comportará exactamente como sqrt((double)0), y lo mismo ocurre con cualquier otra expresión de tipo entero que se use allí.

printfes diferente. Es diferente porque requiere un número variable de argumentos. Su función prototipo es

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

Por tanto, cuando escribes

printf(message, 0);

el compilador no tiene ninguna información sobre qué tipo printf espera que sea ese segundo argumento. Solo tiene el tipo de expresión de argumento, que es int, para pasar. Por lo tanto, a diferencia de la mayoría de las funciones de la biblioteca, depende de usted, el programador, asegurarse de que la lista de argumentos coincida con las expectativas de la cadena de formato.

(Los compiladores modernos pueden buscar en una cadena de formato y decirle que tiene una falta de coincidencia de tipos, pero no van a comenzar a insertar conversiones para lograr lo que quería decir, porque mejor su código debería romperse ahora, cuando lo notará , que años después cuando se reconstruyó con un compilador menos útil).

Ahora, la otra mitad de la pregunta era: dado que (int) 0 y (float) 0.0 están, en la mayoría de los sistemas modernos, ambos representados como 32 bits, todos los cuales son cero, ¿por qué no funciona de todos modos, por accidente? El estándar C simplemente dice "esto no es necesario para funcionar, estás solo", pero déjame explicarte las dos razones más comunes por las que no funcionaría; eso probablemente le ayudará a comprender por qué no es necesario.

Primero, por razones históricas, cuando se pasa a floattravés de una lista de argumentos variables, se asciende a la doubleque, en la mayoría de los sistemas modernos, tiene 64 bits de ancho. Por lo tanto, printf("%f", 0)pasa solo 32 bits cero a un destinatario que espera 64 de ellos.

La segunda razón, igualmente significativa, es que los argumentos de la función de punto flotante pueden pasarse en un lugar diferente al de los argumentos enteros. Por ejemplo, la mayoría de las CPU tienen archivos de registro separados para enteros y valores de punto flotante, por lo que podría ser una regla que los argumentos del 0 al 4 vayan en los registros r0 a r4 si son enteros, pero de f0 a f4 si son de punto flotante. Entonces printf("%f", 0)busca en el registro f1 ese cero, pero no está allí en absoluto.

Por lo general, cuando llama a una función que espera un double, pero proporciona un int, el compilador se convertirá automáticamente en a doublepor usted. Eso no sucede con printf, porque los tipos de argumentos no se especifican en el prototipo de la función; el compilador no sabe que se debe aplicar una conversión.

¿Por qué el uso de un literal entero en lugar de un literal flotante causa este comportamiento?

Porque printf()no tiene parámetros escritos además const char* formatstringdel primero. Utiliza una elipsis de estilo c ( ...) para el resto.

Simplemente decide cómo interpretar los valores pasados ​​allí de acuerdo con los tipos de formato dados en la cadena de formato.

Tendrías el mismo tipo de comportamiento indefinido que cuando intentas

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

El uso de un printf()especificador "%f"y un tipo (int) 0que no coinciden conduce a un comportamiento indefinido.

Si una especificación de conversión no es válida, el comportamiento no está definido. C11dr §7.21.6.1 9

Causas candidatas de UB.

1. Es UB por especificación y la compilación es insoportable '', dijo Nuf.

2. doubley intson de diferentes tamaños.

3. doubley intpueden pasar sus valores usando diferentes pilas (general frente a pila FPU ).

4. Es double 0.0 posible que A no esté definido por un patrón de bits completamente cero. (raro)

Esta es una de esas grandes oportunidades para aprender de las advertencias de su 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);
  ^

o

$ 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.

Entonces, printfestá produciendo un comportamiento indefinido porque le está pasando un tipo de argumento incompatible.

No estoy seguro de qué es confuso.

Su cadena de formato espera un double; en su lugar, proporciona un int.

Si los dos tipos tienen el mismo ancho de bits es completamente irrelevante, excepto que puede ayudarlo a evitar las excepciones de violación de la memoria por un código roto como este.

"%f\n"garantiza un resultado predecible solo cuando el segundo printf()parámetro tiene el tipo de double. A continuación, los argumentos adicionales de las funciones variadas están sujetos a la promoción de argumentos predeterminados. Los argumentos enteros se incluyen en la promoción de enteros, lo que nunca da como resultado valores con tipo de punto flotante. Y los floatparámetros se promueven a double.

Para colmo: estándar permite que el segundo argumento sea o floato doubley nada más.

Por qué es formalmente UB ahora se ha discutido en varias respuestas.

La razón por la que obtiene específicamente este comportamiento depende de la plataforma, pero probablemente sea la siguiente:

• printfespera sus argumentos de acuerdo con la propagación estándar de vararg. Eso significa que un floatserá un doubley cualquier cosa más pequeña que un intserá unint .
• Estás pasando un intdonde la función espera un double. Su intes probablemente de 32 bits, el double64 bits. Eso significa que los cuatro bytes de la pila que comienzan en el lugar donde se supone que debe estar el argumento están 0, pero los siguientes cuatro bytes tienen contenido arbitrario. Eso es lo que se utiliza para construir el valor que se muestra.

La causa principal de este problema de "valor indeterminado" se encuentra en la conversión del puntero en el intvalor pasado a la printfsección de parámetros de variable a un puntero en los doubletipos queva_arg realiza la macro.

Esto provoca una referencia a un área de memoria que no se inicializó completamente con el valor pasado como parámetro a printf, porque el doubletamaño del área de la memoria intermedia de memoria es mayor que el inttamaño.

Por lo tanto, cuando este puntero es desreferenciado, se devuelve un valor indeterminado, o mejor un "valor" que contiene en parte el valor pasado como parámetro printf, y la parte restante podría provenir de otra área de búfer de pila o incluso un área de código ( levantando una excepción de falla de memoria), un desbordamiento real del búfer .


Puede considerar estas porciones específicas de implementaciones de código semplificado de "printf" y "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..
.... 

la implementación real en vprintf (considerando gnu impl.) de la gestión de casos de código de parámetros de doble valor es:

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);

referencias

1. implementación glibc del proyecto gnu de "printf" (vprintf))
2. ejemplo de código de amplificación de printf
3. ejemplo de código de amplificación de va_arg