当一个 int 被强制转换为 short 并被截断时，新值是如何确定的？

Question

有人可以澄清在 C 中将整数转换为 short 时会发生什么吗？我使用的是 Raspberry Pi，所以我知道 int 是 32 位，因此 short 必须是 16 位。

假设我使用以下 C 代码示例：

int x = 0x1248642;
short sx = (short)x;
int y = sx;

我知道x 会被截断，但有人能解释一下具体是如何截断的吗？是否使用轮班？一个数字究竟是如何从 32 位截断到 16 位的？

Answer 1

根据 ISO C 标准，当您将整数转换为有符号类型，并且值超出目标类型的范围时，结果是实现定义的。 （或者可以引发实现定义的信号，但我不知道有任何编译器会这样做。）

在实践中，最常见的行为是丢弃高位。所以假设int 是32 位，short 是16 位，转换值0x1248642 可能会产生一个看起来像0x8642 的位模式。并且假设有符号类型的二进制补码表示（几乎所有系统都使用），高位是符号位，因此结果的数值将为-31166。

int y   =   sx;

这还涉及从short 到int 的隐式转换。由于int 的范围保证至少覆盖short 的整个范围，因此该值不变。 （因为在您的示例中，sx 的值恰好是负数，这种表示形式的更改很可能涉及 符号扩展，将 1 符号位传播到所有 16 个高阶位结果。）

正如我所指出的，语言标准不需要这些细节。如果您真的想将值截断为更窄的类型，最好使用无符号类型（具有语言指定的环绕行为）以及可能的显式屏蔽操作，如下所示：

unsigned int x = 0x1248642;
unsigned short sx = x & 0xFFFF;

如果您想要将一个 32 位的数量放入一个 16 位的变量中，那么您应该做的第一件事是决定在该值不适合时您希望您的代码如何表现。一旦你决定了，你就可以弄清楚如何编写你想要的 C 代码。有时截断恰好是您想要的，在这种情况下，您的任务将很容易，尤其是在您使用无符号类型时。有时超出范围的值是错误，在这种情况下，您需要检查它并决定如何处理错误。有时您可能希望值​​饱和，而不是截断，因此您需要编写代码来执行此操作。

了解如何在 C 中进行转换很重要，但如果您开始从这个问题开始，您可能会从错误的方向解决问题。

Answer 2

32 位值被截断为 16 位，就像将 32 厘米长的香蕉面包塞进 16 厘米长的平底锅中一样，它会被切开。一半可以放进去，仍然是香蕉面包，其余的将“消失”。

Answer 3

截断发生在 CPU 寄存器中。它们有不同的大小：8/16/32/64 位。现在，你可以想象一个像这样的寄存器：

<--rax----------------------------------------------------------------> (64-bit)
                                    <--eax----------------------------> (32-bit)
                                                      <--ax-----------> (16-bit)
                                                      <--ah--> <--al--> (8-bit high & low)
01100011 01100001 01110010 01110010 01111001 00100000 01101111 01101110

x 首先被赋予 32 位值 0x1248642。在内存*中，它看起来像：

-----------------------------
|  01  |  24  |  86  |  42  |
-----------------------------
 31..24 23..16 15..8  7..0       

现在，编译器将x 加载到一个寄存器中。从中，它可以简单地加载最低有效 16 位（即ax）并将它们存储到sx。

---

*为简单起见，不考虑字节顺序

Answer 4

只是从整数中去掉高 16 位。因此，您的空头将变为 0x8642，这实际上是负数 -31166。

Answer 5

也许让代码自己说话：

#include <stdio.h>

#define BYTETOBINARYPATTERN "%d%d%d%d%d%d%d%d"
#define BYTETOBINARY(byte)  \
   ((byte) & 0x80 ? 1 : 0), \
   ((byte) & 0x40 ? 1 : 0), \
   ((byte) & 0x20 ? 1 : 0), \
   ((byte) & 0x10 ? 1 : 0), \
   ((byte) & 0x08 ? 1 : 0), \
   ((byte) & 0x04 ? 1 : 0), \
   ((byte) & 0x02 ? 1 : 0), \
   ((byte) & 0x01 ? 1 : 0) 

int main()
{
    int x    =   0x1248642;
    short sx = (short) x;
    int y    =   sx;

    printf("%d\n", x);
    printf("%hu\n", sx);
    printf("%d\n", y);

    printf("x: "BYTETOBINARYPATTERN" "BYTETOBINARYPATTERN" "BYTETOBINARYPATTERN" "BYTETOBINARYPATTERN"\n",
        BYTETOBINARY(x>>24), BYTETOBINARY(x>>16), BYTETOBINARY(x>>8), BYTETOBINARY(x));

    printf("sx: "BYTETOBINARYPATTERN" "BYTETOBINARYPATTERN"\n",
        BYTETOBINARY(y>>8), BYTETOBINARY(y));

    printf("y: "BYTETOBINARYPATTERN" "BYTETOBINARYPATTERN" "BYTETOBINARYPATTERN" "BYTETOBINARYPATTERN"\n",
        BYTETOBINARY(y>>24), BYTETOBINARY(y>>16), BYTETOBINARY(y>>8), BYTETOBINARY(y));

    return 0;
}

输出：

19170882
34370
-31166

x: 00000001 00100100 10000110 01000010
sx: 10000110 01000010
y: 11111111 11111111 10000110 01000010

如您所见，int -> short 产生低 16 位，正如预期的那样。

将short 转换为int 会产生设置了16 个高位的short。但是，我怀疑这是特定于实现且未定义的行为。您实际上是在将 16 位内存解释为一个整数，它读取 16 位额外的任何垃圾（如果编译器很好并且希望帮助您更快地找到错误，则为 1）。

我认为执行以下操作应该是安全的：

int y = 0x0000FFFF & sx;

显然您不会找回丢失的位，但这将保证高位正确归零。

如果有人可以通过权威参考验证 short -> int 高位行为，将不胜感激。

注意：二进制宏改编自this answer。

Answer 6

sx 的值将与x 的 2 个最低有效字节相同，在这种情况下，它将是 0x8642（如果解释为 16 位有符号整数）以十进制形式给出 -31166。