我从计算机系统：程序员的角度一书中了解到，IEEE标准要求使用以下64位二进制格式表示双精度浮点数：
+无穷大用特殊值表示，具有以下模式：
我认为double的完整64位应按以下顺序排列：
（S）（EXP）（FRAC）
所以我编写以下C代码来验证它：
//Check the infinity
double x1 = (double)0x7ff0000000000000; // This should be the +infinity
double x2 = (double)0x7ff0000000000001; // Note the extra ending 1, x2 should be NaN
printf("\nx1 = %f, x2 = %f sizeof(double) = %d", x1,x2, sizeof(x2));
if (x1 == x2)
printf("\nx1 == x2");
else
printf("\nx1 != x2");
但结果是：
x1 = 9218868437227405300.000000, x2 = 9218868437227405300.000000 sizeof(double) = 8
x1 == x2
为什么数字是有效数字而不是无穷大错误？
为什么x1 == x2？
（我正在使用MinGW GCC编译器。）
我修改了如下代码，并成功验证了Infinity和NaN。
//Check the infinity and NaN
unsigned long long x1 = 0x7ff0000000000000ULL; // +infinity as double
unsigned long long x2 = 0xfff0000000000000ULL; // -infinity as double
unsigned long long x3 = 0x7ff0000000000001ULL; // NaN as double
double y1 =* ((double *)(&x1));
double y2 =* ((double *)(&x2));
double y3 =* ((double *)(&x3));
printf("\nsizeof(long long) = %d", sizeof(x1));
printf("\nx1 = %f, x2 = %f, x3 = %f", x1, x2, x3); // %f is good enough for output
printf("\ny1 = %f, y2 = %f, y3 = %f", y1, y2, y3);
结果是：
sizeof(long long) = 8
x1 = 1.#INF00, x2 = -1.#INF00, x3 = 1.#SNAN0
y1 = 1.#INF00, y2 = -1.#INF00, y3 = 1.#QNAN0
详细输出看起来有点奇怪，但我认为重点很明确。
PS：似乎没有必要进行指针转换。只需使用%f告诉printf函数以unsigned long long格式解释double变量。
出于好奇，我用以下代码检查了变量的位表示。
typedef unsigned char *byte_pointer;
void show_bytes(byte_pointer start, int len)
{
int i;
for (i = len-1; i>=0; i--)
{
printf("%.2x", start[i]);
}
printf("\n");
}
我尝试了以下代码：
//check the infinity and NaN
unsigned long long x1 = 0x7ff0000000000000ULL; // +infinity as double
unsigned long long x2 = 0xfff0000000000000ULL; // -infinity as double
unsigned long long x3 = 0x7ff0000000000001ULL; // NaN as double
double y1 =* ((double *)(&x1));
double y2 =* ((double *)(&x2));
double y3 = *((double *)(&x3));
unsigned long long x4 = x1 + x2; // I want to check (+infinity)+(-infinity)
double y4 = y1 + y2; // I want to check (+infinity)+(-infinity)
printf("\nx1: ");
show_bytes((byte_pointer)&x1, sizeof(x1));
printf("\nx2: ");
show_bytes((byte_pointer)&x2, sizeof(x2));
printf("\nx3: ");
show_bytes((byte_pointer)&x3, sizeof(x3));
printf("\nx4: ");
show_bytes((byte_pointer)&x4, sizeof(x4));
printf("\ny1: ");
show_bytes((byte_pointer)&y1, sizeof(y1));
printf("\ny2: ");
show_bytes((byte_pointer)&y2, sizeof(y2));
printf("\ny3: ");
show_bytes((byte_pointer)&y3, sizeof(y3));
printf("\ny4: ");
show_bytes((byte_pointer)&y4, sizeof(y4));
输出结果为：
x1: 7ff0000000000000
x2: fff0000000000000
x3: 7ff0000000000001
x4: 7fe0000000000000
y1: 7ff0000000000000
y2: fff0000000000000
y3: 7ff8000000000001
y4: fff8000000000000 // <== Different with x4
奇怪的是，尽管x1和x2的位模式与y1和y2相同，但x4与y4不同。
和
printf("\ny4=%f", y4);
给出了这个：
y4=-1.#IND00 // What does it mean???
为什么他们不一样？ y4是如何获得的？
答案 0 :(得分：20)
首先，0x7ff0000000000000确实是双无穷大的位表示。但是强制转换不设置位表示，它将0x7ff0000000000000的逻辑值转换为64位整数。因此，您需要使用其他一些方法来设置位模式。
设置位模式的直接方法是
uint64_t bits = 0x7ff0000000000000;
double infinity = *(double*)&bits;
但是，这是未定义的行为。 C标准禁止读取已存储为一种基本类型（uint64_t）的值作为另一种基本类型（double） 。这称为严格别名规则，并允许编译器生成更好的代码，因为它可以假定一种类型的读取顺序和另一种类型的写入无关紧要。
此规则的唯一例外是char类型：明确允许您将任何指针强制转换为char*并返回。所以你可以尝试使用这段代码：
char bits[] = {0x7f, 0xf0, 0, 0, 0, 0, 0, 0};
double infinity = *(double*)bits;
即使这不是未定义的行为，它仍然是实现定义的行为：double中的字节顺序取决于您的计算机。给定的代码适用于ARM和Power系列等大端机器，但不适用于X86。对于X86，您需要此版本：
char bits[] = {0, 0, 0, 0, 0, 0, 0xf0, 0x7f};
double infinity = *(double*)bits;
实际上没有办法解决此实现定义的行为，因为无法保证计算机将以与整数值相同的顺序存储浮点值。甚至有机器使用这样的字节顺序：＆lt; 1,0,3,2＆gt;我甚至不想知道是谁想出了这个好主意，但它存在，我们必须忍受它。
对于你的上一个问题：浮点运算与整数运算本质上是不同的。这些位具有特殊含义，浮点单元将其考虑在内。特别是像无穷大，NAN和非规范化数字这样的特殊值以特殊方式处理。由于+inf + -inf被定义为产生NAN，因此您的浮点单元会发出NAN的位模式。整数单元不知道无穷大或NAN，所以它只是将位模式解释为一个巨大的整数，并愉快地执行整数加法（在这种情况下恰好溢出）。得到的位模式不是NAN的模式。它恰好是一个非常巨大的正浮点数的位模式（确切地说是2^1023），但这没有任何意义。
实际上，有一种方法可以以可移植的方式设置除NAN之外的所有值的位模式：给定三个包含符号，指数和尾数位的变量，您可以这样做：
uint64_t sign = ..., exponent = ..., mantissa = ...;
double result;
assert(!(exponent == 0x7ff && mantissa)); //Can't set the bits of a NAN in this way.
if(exponent) {
//This code does not work for denormalized numbers. And it won't honor the value of mantissa when the exponent signals NAN or infinity.
result = mantissa + (1ull << 52); //Add the implicit bit.
result /= (1ull << 52); //This makes sure that the exponent is logically zero (equals the bias), so that the next operation will work as expected.
result *= pow(2, (double)((signed)exponent - 0x3ff)); //This sets the exponent.
} else {
//This code works for denormalized numbers.
result = mantissa; //No implicit bit.
result /= (1ull << 51); //This ensures that the next operation works as expected.
result *= pow(2, -0x3ff); //Scale down to the denormalized range.
}
result *= (sign ? -1.0 : 1.0); //This sets the sign.
这使用浮点单元本身将位移动到正确的位置。由于无法使用浮点运算与NAN的尾数位进行交互，因此无法在此代码中包含NAN的生成。好吧，你可以生成一个NAN，但是你无法控制它的尾数位模式。
答案 1 :(得分：8)
初始化
double x1=(double)0x7ff0000000000000;
将转换整数个字面值转换为double。您可能希望共享按位表示。这是特定于实现的（可能是unspecified bahavior），但您可以使用union：
union { double x; long long n; } u;
u.n = 0x7ff0000000000000LL;
然后使用u.x;我假设你的机器上long long和double都是64位。 endianess和floating point表示也很重要。
另见http://floating-point-gui.de/
请注意，并非所有处理器都是x86，并且并非所有浮点实现都是IEEE754（即使在2014年大多数都是）。您的代码可能在ARM处理器上无法正常工作，例如在平板电脑中。
答案 2 :(得分：7)
您将该值转换为双精度值，并且不会按预期运行。
double x1=(double)0x7ff0000000000000; // Not setting the value directly
为了避免这个问题，您可以将该值解释为双指针并取消引用它（虽然这是非常不推荐的，但只适用于无符号long long == double size约束）：
unsigned long long x1n = 0x7ff0000000000000ULL; // Inf
double x1 = *((double*)&x1n);
unsigned long long x2n = 0x7ff0000000000001ULL; // Signaling NaN
double x2 = *((double*)&x2n);
printf("\nx1=%f, x2=%f sizeof(double) = %d", x1, x2, sizeof(x2));
if (x1 == x2)
printf("\nx1==x2");
else
printf("\nx1!=x2"); // x1 != x2
答案 3 :(得分：6)
您将常量0x7ff00... 转换为double。这与获取该值的位表示并将其解释为double完全相同。
这也解释了为什么x1==x2。当你转换为double时，你会失去精确度;所以有时对于大整数，你最终得到的double在两种情况下是相同的。这给你一些奇怪的效果，对于一个大的浮点值，加1使它保持不变。