C: ¿cómo se almacena el número doble (p. Ej., 123.45) en una variable flotante o variable doble o variable doble larga?

#include  int main () { float a = 123.0; unsigned char ch, *cp; ch = 0xff; cp = (unsigned char *) &a; printf ("%02x", ch&(*(cp+3))); printf ("%02x", ch&(*(cp+2))); printf ("%02x", ch&(*(cp+1))); printf ("%02x\n", ch&(*(cp+0))); /*I have written this program to see binary representation, but I can not understand the output, the binary representation? } 

Ver Wikipedia: http://en.wikipedia.org/wiki/Single_precision_floating-point_format , que describe un punto flotante de precisión simple (un float típico de C, pero depende del comstackdor) como un signo de 1 bit, exponente con polarización de 8 bit, y mantisa de 24 bits (23 bits almacenados).

Para su ejemplo:

123.0 = 42f60000 hex = 0 10000101 11101100000000000000000 bin
Signo de 1 bit = 0 (indicando número positivo)
Exponente sesgado de 8 bits = 10000101 bin = 133 dec – 127 dec = 6 dec
Mantisa de 23 bits = 11101100000000000000000 bin = 1.111011 bin (nota implícita líder 1)

Convertir 1.111011 bin x 2 6 dec = 1111011.0 bin = 123.0 dec

Adivinando acerca de su pregunta, how is double number (eg 123.45) stored in a float variable or double variable or long double variable? : Si almacena un valor doble (como el literal “123.0”) en una variable flotante, el comstackdor static_cast el valor static_cast para que se convierta en un valor flotante válido.

Así, aparte de las posibles advertencias del comstackdor, las siguientes

 int main () { float foo = 123.0; } 

es básicamente lo mismo que

 int main () { float foo = static_cast(123.0); } 

Si desea establecer explícitamente un literal flotante, use f o F postfix:

 int main () { float foo = 123.0f; // alternatively: 123.f, 123.F } 

editar: Desde el estándar

Solo busqué la gramática de los literales flotantes, para los curiosos:

 floating-literal: fractional-constant exponent-part_opt floating-suffix_opt digit-sequence exponent-part floating-suffix_opt fractional-constant: digit-sequence_opt . digit-sequence digit-sequence . exponent-part: e sign_opt digit-sequence E sign_opt digit-sequence 

Aquí hay algunos ejemplos de literales de punto flotante que no requieren conversión (pero posiblemente redondeo):

 float a = 1.f, b = 1.0f, c = .0f, d = 1e1f, e = 1.e1f, f = 1e-1f, g = 1e+1f, h = 1E+1F; 

Si se necesita conversión, por ejemplo

 float a = 1., // double b = 1.L,// long double c = 1; // integer 

Se aplica lo siguiente:

4.8 Conversiones de punto flotante [conv.double]

Un valor de tipo de punto flotante se puede convertir en un valor de otro tipo de punto flotante. Si el valor de origen se puede representar exactamente en el tipo de destino, el resultado de la conversión es esa representación exacta. Si el valor de origen se encuentra entre dos valores de destino adyacentes, el resultado de la conversión es una elección definida por la implementación de cualquiera de esos valores. De lo contrario, el comportamiento es indefinido.

4.9 Conversiones flotantes integrales_ [conv.fpint]:

Un rvalue de un tipo entero o de un tipo de enumeración se puede convertir en un rvalue de un tipo de punto flotante. El resultado es exacto si es posible. Un rvalue de un tipo entero o de un tipo de enumeración se puede convertir en un rvalue de un tipo de punto flotante. El resultado es exacto si es posible. De lo contrario, es una opción definida por la implementación del siguiente valor representable más bajo o más alto.

Entonces, en resumen, si pones un literal de tipo double o long double (o algún entero) en un float , el comstackdor convertirá implícitamente ese valor, si se puede convertir exactamente. De lo contrario, depende de la plataforma cómo se almacena el resultado; en caso de que el valor exceda el rango representable, ingresa al mundo de comportamiento indefinido * .


* El temido reino de la conducta indefinida, donde un malvado comstackdor puede encontrar divertido emitir un sonido infernal a través de tus altavoces y hacer que te desangres, y aún así ser sancionado por la norma (aunque no necesariamente por las leyes locales) .

Para comprender cómo funciona el diseño binario de las variables de punto flotante, le recomiendo que lea el artículo de wikipedia de la estandarización correspondiente.

En pocas palabras, todos los números de punto flotante ( float , double , double long double , respectivamente, implementaciones de la half ) consisten en una mantisa y un exponente para representar el número.