La relación entre el número de bytes ocupados por los tipos de datos en lenguaje C y sus rangos de valores
1. La codificación de enteros toma el tipo de carácter como ejemplo.
El tipo de carácter ocupa 1 byte y los últimos 8 bits son bits binarios, por lo que hay 2^8 = 256 combinaciones de codificación. Si representa un tipo de carácter sin signo, generalmente representa 256 números 0, 255.
Si representa un tipo de carácter con signo, si representa un número positivo y el signo más alto es 0, entonces el entero positivo más grande que se puede representar es:
0-111 111, convertido a decimal es 127. De la misma forma, el símbolo 1 representa un número negativo. El número negativo más pequeño es
1-000 0000, que es -128 cuando se convierte a decimal, por lo que el rango representado por el tipo de carácter con signo es [-128, 127].
En términos generales, se supone que el tipo de datos entero ocupa n dígitos binarios. Si representa un entero sin signo, el rango de valores es [0, 2n-1]; si representa un entero con signo, es -2 (n-1), 2 (n-1)-1.
2. Tipo de punto flotante
La codificación de números de punto flotante generalmente adopta las reglas de codificación IEEE754. Este formato de codificación señala principalmente los bits binarios ocupados por el bit efectivo, el exponente y el bit de signo del número de punto flotante. Resumido brevemente como:
¿Formato? ¿longitud? ¿Bit de índice de bit de signo? ¿Número de mantisa? ¿Dígitos efectivos? ¿Cambio exponencial? Descripción de mantisa
Precisión simple 32 1? 8 ? 23 ? 24 127 ?
Doble precisión 64 1? 11 ? 52 ? 53 ?
Doble extendido 80 1? 15 ? 64 ? 64 ? Sin bits ocultos
Nota: El formato doble extendido no tiene bits ocultos, por lo que sus dígitos significativos son los mismos. dígitos de mantisa Los números son los mismos, pero tanto el formato de precisión simple como el de precisión doble tienen un bit oculto, por lo que el número de dígitos significativos es 1 más que el número de dígitos de mantisa.
Generalmente, el rango de valores de los números de coma flotante rara vez se calcula manualmente. Puedes calcularlo usando el programa a continuación.
#¿Incluir? ltstdio.h gt
typedef? estructura? FP_SINGLE
{
¿No está firmado? __int32? ¿Fracción? :?23;
¿Sin firmar? __int32? experiencia:? 8;
¿No está firmado? __int32? ¿firma? :?1;
}?fp_single
typedef? estructura? FP_DOUBLE
{
¿Sin firmar? __int64? ¿Fracción? :?52;
¿Sin firmar? __int64? experiencia:? 11;
¿No está firmado? __int64? ¿firma? :?1;
}?fp _ doble
typedef? estructura? Punto flotante doble
{
¿Sin firmar? __int64? Puntuación;
¿Sin firmar? __int32? experiencia:? 15;
¿No está firmado? __int32? ¿firma? :?1;
}?fp_ex_double
int? main()
{
¿Flotador? x;
fp_Single? *?fp_s? =?(fp_single?*) amp;x;
FP_s- gt;firma? =?0;
FP_s-gt;exp? =?0xfe
FP_s-gt; =?0x7fffff
printf? ("¿Flotador? Cantidad máxima: le\n ", (doble)x);
FP_s-gt; =?0;
FP_s-gt;exp? =?0x 1;
FP_sgt; puntuación? =?0x0
printf? ("¿Flotador? Cantidad mínima: le\n ", (doble)x);
FP_s-gt; =?0;
FP_s-gt;exp? =?0;
FP_s-gt; puntuación? =?0x 1;
printf? ("¿Flotador? Número canónico débil mínimo: le\n\n ", (doble)x);
¿Doble? y;
fp_double? *?fp_d? =?(fp_double?*) amp;y;
FP _ d- gt;firma? =?0;
FP_d-gt;exp? =?0x7fe
FP _ d- gt; =?0xffffffffffffff
printf? ("doble?cantidad máxima:le\n",?y);
FP_d-gt;Firma? =?0;
FP_d-gt;exp? =?0x 1;
FP _ d- gt; =?0x0
printf? ("¿Doble? Cantidad mínima: le\n "?y);
FP_d-gt; =?0;
FP_d-gt;exp? =?0;
FP_d- gt; =?0x 1;
printf? ("¿doble? número canónico débil mínimo: le\n\n ",? y);
Char? canal[10];
fp_ex_double? *?fp_ex_d? =?(fp_ex_double?*)ch;
FP _ ex _ d- gt; =?0;
>FP_ex_d-gt;exp? =?0x 7 FFE;
FP _ ex _ d- gt; puntuación? =?0xffffffffffffffff
//?¿No sabes cómo generar números de punto flotante extendidos de doble precisión?
//?Pero puedes usar el seguimiento de od y luego buscar la dirección del canal [0], ¿seleccionar? punto flotante? 80 es un doble largo,
//? Puedes ver el valor.
FP_ex_d-gt; ¿Firma? =?0;
FP _ ex _ d- gt;exp? =?0x 1;
FP _ ex _ d- gt; puntuación? =?0x8000000000000000
FP_ex_d-gt;¿Firma? =?0;
FP _ ex _ d- gt;exp? =?0;
FP _ ex _ d- gt; =?0x 1;
¿Regresión? 0;
}