Tipo de datos en lenguaje C: punto flotante

Punto de conocimiento 1: tipo de datos de coma flotante

1) Los tipos de datos de punto flotante incluyen flotante (punto flotante de precisión simple), doble (punto flotante de doble precisión), doble largo (punto flotante de precisión larga).

2) Dado que la posición decimal puede flotar, la forma exponencial de los números reales se llama número de punto flotante.

3) Dado que un número real se representa en forma binaria y la longitud de la unidad de almacenamiento es limitada, es imposible obtener un valor completamente exacto y sólo se puede almacenar con una precisión limitada. Cuantos más bits ocupe la parte decimal , más dígitos significativos tendrá el número y mayor será la precisión. Cuantos más dígitos ocupe la parte del exponente, más amplio será el rango de valores que se pueden expresar.

Punto de conocimiento 2: el rango de valores de los números de punto flotante

Punto de conocimiento 3: representación de números en coma flotante

1) Forma decimal: compuesta por números y puntos decimales;

Ejemplo: 3.14, 4., .4, .0, 0.

2) Forma exponencial: "decimal decimal o entero" + "e (o E)" + "decimal entero". Debe haber números en ambos lados de e (o E) y no se pueden omitir.

Ejemplo: 3,5-4 significa 3,5*10*(-4), 5,4E+8

3) El tipo de número de punto flotante de precisión simple tiene solo 6 dígitos válidos después del punto decimal;

4) El número de dígitos significativos del tipo de número de punto flotante de doble precisión puede alcanzar los 16 bits;

5) La mayoría de los compiladores de C estipulan que se conservan un máximo de 6 dígitos después del punto decimal y las partes restantes se redondean;

Punto de conocimiento 4: Definición de números de coma flotante

A través del delimitador de tipo, puede definir una variable de tipo punto flotante de la misma manera que define una variable entera;

identificador [definidor de tipo];

fnum flotante; doble fondo;

Las variables de tipo punto flotante también se pueden generar usando la función printf(). La diferencia con las variables enteras es: el elemento de especificación de formato de float es "%f" y el elemento de especificación de formato de double es "%f".

Punto de conocimiento 5: Procesamiento de valores con decimales

#include <stdio.h>
int main()
{
int a = 1.234567;
int b = 0.00001;
int c = 365.12345;
printf("%d\n", a);
printf("%d\n", b);
printf("%d\n", c);
return 0;
}

El resultado es 1 0 365. Es decir, se pierde la parte decimal;

1) Reemplazamos el tipo entero int en el código anterior con el tipo float de precisión simple. Después de eso, el marcador de posición en printf("%d\n",a); es %d, por lo que lo reemplazamos con %f. (El marcador de posición %d se usa para tipos enteros, el marcador de posición %f se usa para tipos de punto flotante);

#include <stdio.h>
int main()
{
float a = 1.234567;
float b = 0.00001;
float c = 365.12345;
printf("%f\n", a);
printf("%f\n", b);
printf("%f\n", c);
return 0;
}
结果：1.2345567
      0.000010
      365.123444

2) Después de reemplazar int con float, la mayoría de los datos son correctos. Pero 365,12345 se convirtió en 365,123444. Es obvio que hay un error de precisión. Esto se debe a que los números de punto flotante no pueden representar una precisión infinita y habrá ciertos errores;

3) El estándar C estipula que el tipo flotante debe poder representar al menos 6 dígitos significativos y el rango de valores es al menos 10 ^ -37 ~ 10 + 37. Por lo tanto, cuando se usa float para mantener 365.12345, los primeros seis dígitos son precisos, pero los siguientes valores son ligeramente inexactos;

4) Reemplazamos float en el código anterior con double;

#include <stdio.h>
int main()
{
double a = 1.234567;
double b = 0.00001;
double c = 365.12345;
printf("%f\n", a);
printf("%f\n", b);
printf("%f\n", c);
return 0;
}
结果：1.234567
     0.000010
     365.123450

Esta vez 365.12345 también es correcto;

* El tipo doble también tiene un rango de precisión. Si se trata de datos de mayor precisión, el doble también tendrá errores;

Punto de conocimiento 6: el tamaño de bytes ocupado por los tipos de punto flotante

# Según nuestra experiencia previa con números enteros, cuanto mayor es el rango de tipos de enteros, mayor es el espacio que ocupan. Entonces, para los tipos de punto flotante, cuanto mayor sea la precisión y mayor el rango del tipo de punto flotante, mayor será el espacio que se debe ocupar. Usamos sizeof para medir cuánto espacio ocupan float y double respectivamente.

#include <stdio.h>
int main()
{
printf("sizeof float = %d\n", sizeof(float));
printf("sizeof double = %d\n", sizeof(double));
return 0;
}
结果；sizeof float=4
      sizeof double=8

# float y double tienen 4 y 8 bytes respectivamente. Verifica nuestra suposición anterior de que cuanto mayor sea el rango y mayor la precisión, mayor será el espacio ocupado por el tipo.