float型数据不能比较相等？为什么？

前言

早就听说float型数据不能比较相等或不等，只能比较大小，也一直在程序中避免做相等的判断。但是一直不知道具体原因，直到最近做了一个详细的调查。

测试

为了验证float型数据是否真的不能比较相等，我写了一段测试代码：

#include <stdio.h>

int main(void)
{
    float a1 = 1.1, b1 = 1.1;
    double a2 = 1.1, b2 = 1.1;
    if (a1 == 1.1) {
        printf("a1 == 1.1\n");
    } else {
        printf("a1 != 1.1, a1 = %f\n", a1);
    }
    if (a1 == b1) {
        printf("a1 == b1\n");
    } else {
        printf("a1 != b1\n");
    }
    if (a2 == 1.1) {
        printf("a2 == 1.1\n");
    } else {
        printf("a2 = %lf\n", a2);
    }
	if (a2 == b2) {
        printf("a2 == b2\n");
    } else {
        printf("a2 != b2\n");
    }
	if (a1 == b2) {
        printf("a1 == b2\n");
    } else {
        printf("a1 != b2\n");
    }
    return 0;
}

运行结果如下：

a1 != 1.1, a1 = 1.100000
a1 == b1
a2 == 1.1
a2 == b2
a1 != b2

所以我们可以得到结论：

1. float型数据变量不能直接和数字比较相等。
2. 两个同为float型的数据变量可以比较相等。
3. float型数据不能和double型数据比较相等。
4. double型数据可以直接和数字比较相等。
5. 两个同为double型的数据变量可以比较相等。

原因调查

得到结论以后我们来调查一下原因。
首先我们看一下上面测试程序中float型和double型数据的二进制是什么样的，修改一下代码：

#include <stdio.h>

int main(void)
{
    float a1 = 1.1, b1 = 1.1;
    double a2 = 1.1, b2 = 1.1;
    if (a1 == 1.1) {
        printf("a1 == 1.1\n");
    } else {
        printf("a1 != 1.1, a1 = %f\n", a1);
    }
    if (a1 == b1) {
        printf("a1 == b1\n");
    } else {
        printf("a1 != b1\n");
    }
    if (a2 == 1.1) {
        printf("a2 == 1.1\n");
    } else {
        printf("a2 = %lf\n", a2);
    }
	if (a2 == b2) {
        printf("a2 == b2\n");
    } else {
        printf("a2 != b2\n");
    }
	if (a1 == b2) {
        printf("a1 == b2\n");
    } else {
        printf("a1 != b2\n");
    }
	printf("a1 = 0x%x\n", *(unsigned int *)&a1);
	printf("b1 = 0x%x\n", *(unsigned int *)&b1);
	printf("a2 = 0x%lx\n", *(unsigned long *)&a2);
	printf("b2 = 0x%lx\n", *(unsigned long *)&b2);
    return 0;
}

运行结果如下：

a1 != 1.1, a1 = 1.100000
a1 == b1
a2 == 1.1
a2 == b2
a1 != b2
a1 = 0x3f8ccccd
b1 = 0x3f8ccccd
a2 = 0x3ff199999999999a
b2 = 0x3ff199999999999a

OK，可以看到虽然赋值都是1.1，但是float和double型数据的二进制完全不一样。现在我们来研究一下float和double型数据的格式。

float型数据格式

float型变量在计算机内存中占用4字节，即32bit。遵循IEEE-754标准。
一个float型数据由3部分构成，符号位S(1bit)，指数E(8bit)和底数M(23bit)：
V = (-1) ^S x M x 2^E

1. (-1) ^S 表示符号位，当S=0，V为正数；当S=1，V为负数
2. M表示有效数字，大于等于1，小于2
3. 2^E 表示指数位

IEEE 754 对有效数字M和指数E，还有一些特别规定。
前面说过，1≤ M <2，也就是说，M 可以写成 1.xxxxxx 的形式，其中 xxxxxx 表示小数部分。IEEE754 规定，在计算机内部保存 M 时，默认这个数的第一位总是 1，因此可以被舍去，只保存后面的 xxxxxx 部分。比如保存 1.01 的时候，只保存 01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省 1 位有效数字。以32位浮点数为例，留给 M 只有 23 位，将第一位的1舍去以后，等于可以保存 24 位有效数字。
至于指数 E，情况就比较复杂。
首先，E 为一个无符号整数（unsignedint）。这意味着它的取值范围为 0 ~ 255。但是，我们知道，科学计数法中的E是可以出现负数的，所以 IEEE754 规定，E 的真实值必须再减去一个中间数127.
比如，2^10 的 E 是 10，所以保存成 32 位浮点数时，必须保存成 10+127=137，即 10001001。
然后，指数E还可以再分成三种情况：

1. E不全为0或不全为1。这时，浮点数就采用上面的规则表示，即指数E的计算值减去127，得到真实值，再将有效数字M前加上第一位的1。
2. E 全为 0。这时，浮点数的指数 E 等于 1-127，有效数字 M 不再加上第一位的 1，而是还原为 0.xxxxxx 的小数。这样做是为了表示 ±0，以及接近于 0 的很小的数字。
3. E 全为 1。这时，如果有效数字 M 全为 0，表示 ± 无穷大（正负取决于符号位 s）；如果有效数字 M 不全为 0，表示这个数不是一个数。

我们按照这个格式解析一下测试程序中的“a1 = 0x3f8ccccd”

可见：
S：0，是正数。
E：01111111，转换成十进制是127。127-127=0，即实际指数部分为0。
M：为00011001100110011001101。这里，在底数左边省略存储了一个“1”，所以实际底数表示为1.00011001100110011001101。底数换算成十进制的方法：小数点左边1位“1”表示2⁰ ，小数点右边第“x”位为1，表示2^-x ，为0则忽略。所以这个底数的十进制值为：
2⁰ + 2^-4 + 2^-5 + 2^-8 + 2^-9 + 2^-12 + 2^-13 + 2^-16 + 2^-17 + 2^-20 + 2^-21 + 2^-23
代入
V = (-1) ^S x M x 2^E
得到
V = (-1) ⁰ x （2⁰ + 2^-4 + 2^-5 + 2^-8 + 2^-9 + 2^-12 + 2^-13 + 2^-16 + 2^-17 + 2^-20 + 2^-21 + 2^-23） x 2⁰ = 1.10000002384185
可见float型数据并不能准确的表示1.1这个小数，只能得到近似值。

double型数据格式

除数据长度外，double型数据跟float型数据格式相同，占用内存8个字节，包括符号位S(1bit)，指数E(11bit)和底数M(52bit)。

结论

由此我们可以知道，float和double型数据很多时候并不能准确表示一个小数，只能表示该小数的近似值。即便赋值都是十进制的1.1，float型数据跟double型数据的也并不相等。
所以，并不是float型数据不能比较相等，而是float和double型数据之间不能相互比较是否相等。而计算机内部小数常量是按照double数据存储的，所以float型数据也不能直接和数字比较是否相等。
但是，如果是可以准确表示的小数，比如1.0，就没有这个问题了。

搜索关注公众号“嵌入式小学生”，一起学习呀