从 32 位到 64 位操作系统的无符号整数

Question

这段代码 sn-p 摘自一本 linux 书籍。 如果这不适合在此处发布代码 sn-p，请告诉我。 我会删除它。谢谢。

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
  char buf[30];
  char *p;
  int i;
  unsigned int index = 0;
  //unsigned long index = 0;
  printf("index-1 = %lx (sizeof %d)\n", index-1, sizeof(index-1));
  for(i = 'A'; i <= 'Z'; i++)
      buf[i - 'A'] = i;
  p  = &buf[1];
  printf("%c: buf=%p p=%p p[-1]=%p\n", p[index-1], buf, p, &p[index-1]);
  return 0;
}

在 32 位操作系统环境中： 无论索引的数据类型是 unsigned int 还是 unsigned long，此程序都能正常工作。

在 64 位操作系统环境中： 如果 index 声明为 unsigned int，同一程序将运行到“核心转储”。 但是，如果我只将索引的数据类型从 unsigned int 更改为 a) unsigned long 或 b) unsigned short， 这个程序也很好用。

书上的原因只告诉我64位会由于非负数而导致核心转储。但我不知道 unsigned long 和 unsigned short 工作但 unsigned int 的原因。

我很困惑的是

p + (0u -1) == p + UINT_MAX 当索引为无符号整数时。

但是，

p + (0ul - 1) == p[-1] 当索引为无符号长时。

我卡在这里了。

如果有人能帮忙详细说明一下，不胜感激！

谢谢。

这是我的 32 位的一些结果（RHEL5.10/gcc 版本 4.1.2 20080704）

和64位机（RHEL6.3/gcc版本4.4.6 20120305）

我不确定 gcc 版本在这里是否有什么不同。 所以，我也粘贴了信息。

在 32 位上：

我尝试了两个更改：

1) 将unsigned int index = 0修改为unsigned short index = 0。

2) 将unsigned int index = 0修改为unsigned char index = 0。

程序可以正常运行。

index-1 = ffffffff (sizeof 4)

A: buf=0xbfbdd5da p=0xbfbdd5db p[-1]=0xbfbdd5da

好像索引的数据类型会因为-1而提升为4字节。

在 64 位上：

我尝试了三个更改：

1) 将unsigned int index = 0修改为unsigned char index = 0。

  It works!

index-1 = ffffffff (sizeof 4)

A: buf=0x7fffef304ae0 p=0x7fffef304ae1 p[-1]=0x7fffef304ae0

2) 将unsigned int index = 0修改为unsigned short index = 0。

 It works!

index-1 = ffffffff (sizeof 4)

A: buf=0x7fff48233170 p=0x7fff48233171 p[-1]=0x7fff48233170

3) 将unsigned int index = 0修改为unsigned long index = 0。

 It works!

index-1 = ffffffff (sizeof 8)

A: buf=0x7fffb81d6c20 p=0x7fffb81d6c21 p[-1]=0x7fffb81d6c20

但是，只有

unsigned int index = 0 在最后一个 printf 处运行到核心转储中。

index-1 = ffffffff (sizeof 4)

Segmentation fault (core dumped)

Answer 1

不要对编译器撒谎！

在预期 long (%ld) 的地方传递 printf 和 int 是未定义的行为。
（创建一个指向任何有效对象之外（而不仅仅是在一个对象后面）的指针也是 UB...）

更正格式说明符和指针算法（包括索引作为特殊情况），一切都会正常工作。

_{UB 包括“它按预期工作”以及“灾难性故障”。}

顺便说一句：如果您礼貌地向编译器询问所有警告，它会警告您。使用-Wall -Wextra -pedantic 或类似名称。

Answer 2

另一个问题是代码在您的printf() 中：

  printf("index-1 = %lx (sizeof %d)\n", index-1, sizeof(index-1));

让我们简化一下：

int i = 100;
print("%lx", i-1);

您告诉printf，这里是long，但实际上您发送的是int。 clang 确实告诉你正确的警告（我认为 gcc 也应该吐出正确的警告）。见：

test1.c:6:19: warning: format specifies type 'unsigned long' but the argument has type 'int' [-Wformat]
printf("%lx", i - 100);
        ~~~   ^~~~~~~
        %x   
1 warning generated.

解决方案很简单：您需要将 long 传递给printf 或告诉printf 打印int：

printf("%lx", (long)(i-100) );
printf("%x", i-100);

您在 32 位上很幸运，您的应用没有崩溃。将其移植到 64 位后发现代码中存在错误，您现在可以修复它。

Answer 3

无符号值的算术总是以环绕的方式定义的。例如。 (unsigned)-1 与 UINT_MAX 相同。所以像

这样的表达式

p + (0u-1)

等价于

p + UINT_MAX

（&p[0u-1] 等价于&*(p + (0u-1)) 和p + (0u-1)）。

如果我们用无符号整数类型替换指针，也许这更容易理解。考虑：

uint32_t p32; // say, this is a 32-bit "pointer"
uint64_t p64; // a 64-bit "pointer"

假设 short、int 和 long 分别为 16、32 和 64 位（同一行中的条目相等）：

p32 + (unsigned short)-1    p32 + USHRT_MAX     p32 + (UINT_MAX>>16)
p32 + (0u-1)                p32 + UINT_MAX      p32 - 1
p32 + (0ul-1)               p32 + ULONG_MAX     p32 + UINT_MAX          p32 - 1

p64 + (0u-1)                p64 + UINT_MAX
p64 + (0ul-1)               p64 + ULONG_MAX     p64 - 1

您始终可以将无符号类型上的加法、减法和乘法操作数替换为一致的 modulo 最大值 + 1。例如，

-1 ☰ ffffffff_hex mod 2³²

(ffffffff_hex 是 2³²-1 或 UINT_MAX)，也是

ffffffffffffffff_hex ☰ ffffffff_hex mod 2³²

（对于 32 位无符号类型，您始终可以截断为最不重要的 8 个十六进制数字）。

你的例子：

32 位

• unsigned short index = 0;

在index - 1 中，索引提升为int。结果的类型为int，值为-1（为负数）。 unsigned char 也一样。

64 位

• unsigned char index = 0;
• unsigned short index = 0;

与 32 位相同。 index 提升为int，index - 1 为负数。

• unsigned long index = 0;

输出

index-1 = ffffffff (sizeof 8)

很奇怪，这是你唯一正确使用 %lx 但看起来你已经用 %x 打印了它（预计 4 个字节）；在我的 64 位计算机上（使用 64 位 long）和 %lx 我得到：

index-1 = ffffffffffffffff (sizeof 8)

ffffffffffffffff_hex 是 -1 模 2⁶⁴。

• unsigned index = 0;

int 不能保存任何值 unsigned int 可以，因此在 index - 1 中没有任何内容被提升为 int，结果类型为 unsigned int，值为 -1（正，与 UINT_MAX 或 ffffffff_hex 相同，因为类型是无符号的）。对于 32 位地址，添加此值与减一相同：

    bfbdd5db            bfbdd5db
+   ffffffff          -        1
=  1bfbdd5da
=   bfbdd5da          = bfbdd5da

（注意环绕/截断。）但是对于 64 位地址：

    00007fff b81d6c21
+            ffffffff
=   00008000 b81d6c20

没有环绕。这是试图访问一个无效的地址，所以你得到一个段错误。

也许看看2’s complement on Wikipedia。

---

在我的 64 位 Linux 下，使用期望 32 位值的说明符同时传递 64 位类型（反之亦然）似乎“有效”，只读取 32 个最低有效位。但是使用正确的。 lx 期望 unsigned long，未修改的 x 和 unsigned int，hx 和 unsigned short（当传递给 printf 时，unsigned short 被提升为 int（它作为变量参数传递） ，由于默认参数提升）。 size_t 的长度修饰符是z，如%zu：

printf("index-1 = %lx (sizeof %zu)\n", (unsigned long)(index-1), sizeof(index-1));

（转换为unsigned long 不会更改unsigned int、unsigned short 或unsigned char 表达式的值。）

sizeof(index-1) 也可以写成sizeof(+index)，对表达式大小的唯一影响是通常的算术转换，这也是由一元+ 触发的。