c ++不一致的无符号到有符号减法结果仅对一个排列失败

Question

我意识到有一条规则可以将宽度小于int 的数字提升为更宽的类型以进行加法运算。但我无法完全解释以下print_unsafe_minus 的一个排列如何会失败。为什么只有 <unsigned, long> 示例失败了？程序员在最佳实践方面的收获是什么？

#include <fmt/core.h>

template<typename M, typename N>
void print_unsafe_minus() {
        M a = 3, b = 4;
        N c =  a - b;
        fmt::print("{}\n", c);
}
int main() {
    // storing result of unsigned 3 minus 4 to a signed type

    print_unsafe_minus<uint8_t, int8_t>(); // -1
    print_unsafe_minus<uint16_t, int8_t>(); // -1
    print_unsafe_minus<uint32_t, int8_t>(); // -1
    print_unsafe_minus<uint64_t, int8_t>(); // -1

    print_unsafe_minus<uint8_t, int16_t>(); // -1
    print_unsafe_minus<uint16_t, int16_t>(); // -1
    print_unsafe_minus<uint32_t, int16_t>(); // -1
    print_unsafe_minus<uint64_t, int16_t>(); // -1

    print_unsafe_minus<uint8_t, int32_t>(); // -1
    print_unsafe_minus<uint16_t, int32_t>(); // -1
    print_unsafe_minus<uint32_t, int32_t>(); // -1
    print_unsafe_minus<uint64_t, int32_t>(); // -1

    print_unsafe_minus<uint8_t, int64_t>(); // -1
    print_unsafe_minus<uint16_t, int64_t>(); // -1
    print_unsafe_minus<uint32_t, int64_t>(); // 4294967295
    print_unsafe_minus<uint64_t, int64_t>(); // -1
}

---

（编辑） 另外值得注意的是——如果我们将示例扩展为包含 128 位整数，那么以下两个排列也会失败：

print_unsafe_minus<uint32_t, __int128>(); // 4294967295
print_unsafe_minus<uint64_t, __int128>(); // 18446744073709551615

Answer 1

在开始之前，让我们假设 OP 正在使用 32 位 int 类型的实现。也就是说，int32_t 等价于int。

设 X 为 M 的宽度，Y 为 N 的宽度。

让我们将您的测试用例分为三类：

第一类：X

Integer promotions 在这里适用，总是在before invoking an arithmetic operator 完成。

uint8_t 和uint16_t 的整个值域都可以用int 表示，因此在进行减法之前它们会被提升为int。然后你通过3 - 4得到一个有符号值-1，然后用它来初始化一个有符号整数类型，不管它的宽度如何，它都可以容纳-1。因此你得到-1 作为输出。

第二类：(X >= 32) 和 (X >= Y)

在做减法之前不会发生任何提升。

此处适用的规则是无符号整数运算is always modulo 2^X，其中 X 是整数的宽度。

因此a - b 总是给你 2^X - 1，因为这是在 M 的范围内等于 -1 模 2 的值。

现在您将其分配给签名类型。让我们假设 C++20（在 C++20 之前，当分配一个无法由目标有符号类型表示的无符号值时，它是实现定义的行为）。

这里a - b（即2^X - 1）的结果是converted to the unique value that is congruent to itself在目标范围内模2^Y（即从-2 ^Y-1 到 2^Y-1 - 1)。由于 X >= Y，这将始终是 -1。

所以你得到-1 作为输出。

第三类：(X >= 32) 和 (X

这一类只有一种情况，即M = uint32_t，N = uint64_t的情况。

减法与类别 2 相同，得到 2³² - 1。

转换为有符号类型的规则还是一样的。但是，这一次，2³² - 1 等于自身模 2⁶⁴，所以值保持不变。

注意：4294967295 == 2³² - 1

带走

这可能是 C++ 的一个令人惊讶的方面，正如 @NathanOliver 所建议的那样，您应该避免混合有符号类型和无符号类型，并且在确实想要混合它们时要格外小心。

您可以通过打开-Wconversion 来告诉编译器为此类转换生成警告。你的代码 gets a lot of warnings 开启时。

Answer 2

让我们假设一个健全的二补码平台，其中int 有 32 位，uint32_t 与 unsigned 相同。

    uint32_t a = 3, b = 4;
    int64_t c =  a - b;

- 运算符的操作数经过integral promotions*。 int不能代表uint32_t的所有值，但是32位的unsigned可以代表uint32_t的所有值。这些值被提升为unsigned。 -is the common type of operands 提升后的结果类型 - 两个操作数都是 unsigned。 - 运算符的结果类型为unsigned。 a - b 在数学上是 -1。结果是(unsigned)-1，但unsigned 不能表示负数。所以-1is converted to 是unsigned 类型，它“环绕”并导致UINT_MAX，它等于UINT32_MAX，因为unsigned 有32 位。这个结果可以在int64_t 中表示，所以不会发生转换，c 被分配了 UINT32_MAX 的值。

相比之下，我们以<uint16_t, int64_t> 为例。一个 32 位的int 可以表示一个uint16_t 的所有值，所以uint16_t 被提升为int，所以a - b 的结果只是一个(int)-1。没有从(int)-1 到无符号数的转换。那么int64_t可以代表-1，所以-1的值只是赋给了int64_t类型的变量。

* 在C语言中称为整数提升...