contenido
1. La variable bool se compara con el "valor 0"
2. El número de coma flotante se compara con el "valor 0"
2.1 Comparación entre números de punto flotante
2.2 Número de punto flotante y comparación 0
3. Comparación de variable de puntero y "valor 0"
3.2 Comparación de puntero y 0
1. La variable bool se compara con el "valor 0"
1.1 Introducción al tipo bool
Pregunta: ¿El lenguaje C tiene un tipo bool?
Uno: c89 o c90 no tiene un tipo _bool // c99 introdujo un tipo _Bool
Dos: (detalles) Antes de c99, principalmente c90 no lo tenía.En la actualidad, la mayoría de los libros piensan que no existe tal cosa. Debido a los libros, por lo general tienen que ir a la zaga de la industria. Pero c99 introdujo el tipo _Bool (leíste bien, _Bool es un tipo, pero en el nuevo archivo de encabezado stdbool.h, se reescribió como bool con macros, para garantizar la compatibilidad con C/C++).
En lenguaje C, todos sabemos que 0 significa falso, distinto de 0 significa verdadero
El tipo bool usa verdadero y falso para representar verdadero y falso
Código de prueba 1 : (Este código se compila con VS2013, por lo que hay #include <windows.h> y system("pause");)
#include <stdio.h>
#include <stdbool.h> //没有这个头文件会报错，使用新特性一定要加上
#include <windows.h>
int main()
{
bool ret = false;
ret = true;
printf("%d\n", sizeof(ret)); //vs2013 和 Linux中都是1
system("pause");
return 0;
}
//Ver el código fuente:
#define bool _Bool //c99中是一个关键字哦，后续可以使用bool
#define false 0 //假
#define true 1 //真PD: En teoría, para indicar verdadero o falso, un bit es suficiente, pero este problema aún depende de la comprensión del compilador. En vs2013 se considera de 1 byte.
¡¡pero!!
//Código de prueba 2:
#include <stdio.h>
#include <windows.h>
int main()
{
//在vs中，光标选中BOOL，单击右键，可以看到转到定义，就能看到BOOL是什么
BOOL ret = FALSE;
ret = TRUE;
printf("%d\n", sizeof(ret)); //输出结果是4，因为在源代码中，是这么定义的：typedef int BOOL;
system("pause");
return 0;
}Descubrimos que incluso se puede editar. . . ¿que demonios? ?
Este es un conjunto de valores BOOL hechos por el propio Microsoft. Vaya al archivo de encabezado correspondiente a BOOL en vs, gire hacia arriba y podrá ver la información de derechos de autor de Microsoft. Bien, ¿a quién debo escuchar? ?
¿Microsoft? No se recomienda encarecidamente, el BOOL en mayúsculas es el estándar de Microsoft, el rendimiento multiplataforma es demasiado bajo y la portabilidad es pobre.El código de prueba 1 se puede compilar tanto en VS2013 como en Linux, pero el código 2 solo se puede pasar en VS2013, pero no Linux.
Por lo tanto, en caso de usar bool más adelante, se recomienda encarecidamente el estándar C99 y se abandona Microsoft.
1.2 bool y 0 comparación
Explicación por código:
#include <stdio.h>
#include <stdbool.h>
#include <windows.h>
int main()
{
int pass = 0; //0表示假,C90，我们习惯用int表示bool
//bool pass = false; //C99
if (pass == 0)
{
//理论上可行，但此时的pass是应该被当做bool看待的，==用来进行整数比较，不推荐
//TODO
}
if (pass == false)
{
//不推荐，尽管在C99中也可行
//TODO
}
if (pass)
{
//推荐
//TODO
}
//理论上可行，但此时的pass是应该被当做bool看待的，==用来进行整数比较，不推荐
//另外，非0为真，但是非0有多个，这里也不一定是完全正确的
if (pass != 1)
{
//TODO
}
if (pass != true)
{
//不推荐，尽管在C99中也可行
//TODO
}
if (!pass)
{
//推荐
//TODO
}
system("pause");
return 0;
}2. El número de coma flotante se compara con el "valor 0"
2.1 Comparación entre números de punto flotante
Pérdida de precisión:
Los números de coma flotante se almacenan en la memoria, no lo que pensamos, se almacenan por completo, y cuando el decimal se convierte en binario, puede haber una pérdida de precisión.
Tenga en cuenta que las pérdidas aquí no se reducen ciegamente, sino que también pueden aumentar. Cuando se almacena el número de coma flotante en sí mismo, se "redondeará" u otras estrategias cuando el cálculo es interminable.
P.ej:
#include<stdio.h>
int main()
{
double d = 3.6;
printf("%.50f\n", 3.6);
return 0;
}
Proceso de comparación: (primero mire el código)
#include<stdio.h>
int main()
{
double x = 1.0;
double y = 0.1;
printf("%.50f\n", x - 0.9);
printf("%.50f\n", y);
if ((x - 0.9) == 0.1)
{
printf("you can see me!\n");
}
else
{
printf("oops!\n"); // oops!
}
return 0;
}
//Al comparar números de coma flotante, ¡no debe usar == para compararlos directamente! ! ! !
// Los propios números de coma flotante tienen una pérdida de precisión, lo que a su vez hace que varios resultados sean ligeramente diferentes.
Solución:! !
hoichi:
Código falso:
if((x-y) > -精度 && (x-y) < 精度)
{
//TODO
}Código formal: EPSION personalizado se utiliza aquí para definir el rango de precisión
#include<stdio.h>
#define EPSION 0.00000000001
int main()
{
double x = 1.0;
double y = 0.1;
if (((x - 0.9) - y) > -EPSION && ((x - 0.9) - y) < EPSION)
{
printf("you can see me!\n");
}
else
printf("oops!\n");
return 0;
}Método 2: Usa el método del valor absoluto para resolver este problema
Versión de pseudocódigo:
if(fabs(x-y) < 精度)
{
//fabs是浮点数求绝对值
//TODO
}
Código oficial:
#include<stdio.h>
#include<math.h>
#include<float.h>
int main()
{
double x = 1.0;
double y = 0.1;
if (fabs((x - 0.9) - y) < DBL_EPSILON)
{
printf("you can see me!\n");
}
else
printf("oops!\n");
return 0;
}2.2 Número de punto flotante y comparación 0
Ahora que conoce la comparación entre números de punto flotante, convertir uno de los números de punto flotante a 0 es equivalente a comparar un número de punto flotante con 0
// Para comparar a y b, necesita comparar de la siguiente manera
// fab(a - b) < DBL_EPSILON)
// Compara a y 0, puedes convertir b en el código anterior a 0, de la siguiente manera:
// fab(a) < DBL_EPSILON)
// Explique que siempre que se cumplan los requisitos del código anterior, se puede demostrar que a y 0 son iguales
#include<stdio.h>
#include<math.h>
#include<float.h>
int main()
{
double x = 0.00000000000000000000000000001;
//法一：
/*if (fabs(x) < DBL_EPSILON)
{
printf("you can see me! x==0.0\n");
}
else
{
printf("oops!\n");
}*/
//法二：
if ((x > -DBL_EPSILON) && (x < DBL_EPSILON))
{
printf("you can see me! x==0.0\n");
}
else
{
printf("oops!\n");
}
return 0;
}
/* Pregunta: ¿Quieres usar un signo igual?
// sin: si ((x > -DBL_EPSILON) && (x < DBL_EPSILON))
// con: si ((x >= -DBL_EPSILON) && (x <= DBL_EPSILON))
XXX_EPSILON es error mínimo, pero: XXX_EPSILON+ n es no es igual al menor número positivo de n.
No se puede tomar =
si
pero y + 0.0 == y;
y doble y + DBL_EPSILON != y;
entonces doble y + x != y;
fabs(x) == DBL_EPSILON
así que no escribas un signo igual en el futuro */
3. Comparación de variable de puntero y "valor 0"
3.1 Introducción
Mira el código:
#include<stdio.h>
int main()
{
//类型是不同的
printf("%d\n", 0); //0
printf("%d\n", '\0'); //0
printf("%d\n", NULL); //0
int a = 0;
char* p = NULL;
//这里NULL的值是0是因为发生了强制类型转换
// 如何理解强制类型转换？
// 需要编写算法，或使用相关库函数
// "123456" -> int: 123456
// "123456" 7 字节 int 类型 4 字节 //真实转换
return 0;
}// ******La conversión real cambiará los datos en la memoria******
// ******La conversión de tipo forzado no cambia los datos en la memoria, solo cambia el tipo correspondiente***
3.2 Comparación de puntero y 0
#include<stdio.h>
int main()
{
int* p = NULL;
//if (p == NULL) 不推荐
//if (NULL == p) 推荐
return 0;
}