在 64 位可执行文件中执行 64 位计算

Question

我正在使用 MinGW64（带有 -m64 标志）和 Code::Blocks，我希望知道如何执行 64 位计算，而不必在乘以之前将一个非常大的数字转换为 int64_t。例如，这不会导致溢出：

int64_t test = int64_t(2123123123) * 17; //Returns 36093093091

没有强制转换，计算会像这样溢出：

int64_t test = 2123123123 * 17; //Returns 1733354723

VirusTotal 扫描确认我的可执行文件是 x64。

附加信息：操作系统为 Windows 7 x64。

Answer 1

为了兼容性，即使在 64 位编译中，默认的 int 类型仍然是 32 位。

我猜“最短”的版本是在数字上添加ll 后缀

int64_t test = 2123123123ll * 17;

另一种方法是将数字存储在它们自己的int64_t（或long long）类型的变量中，然后将变量相乘。通常在程序中很少有很多“幻数”硬编码到代码库中。

Answer 2

一些背景：

曾几何时，大多数计算机都有 8 位算术逻辑单元和 16 位地址总线。我们称它们为 8 位计算机。

我们学到的第一件事是，现实世界的算术问题不能用 8 位表示。这就像试图用黑猩猩的算术能力来推理太空飞行。所以我们学会了编写多字加、乘、减和除序列。因为在大多数现实问题中，问题的数值域都大于 255。

我们短暂地拥有 16 位计算机（同样的问题也适用，65535 不足以对事物进行建模），然后很快将 32 位算术逻辑内置到芯片中。渐渐地，地址总线赶上了（20 位、24 位、32 位，如果设计师觉得奢侈的话）。

然后发生了一件有趣的事情。我们大多数人不再需要编写多字算术序列。事实证明，现实世界中的大多数（tm）整数问题都可以用 32 位（最多 40 亿）表示。

然后我们开始以比以往更快的速度生成更多数据，并且我们意识到需要处理更多内存。 64 位计算机最终成为常态。

但是，大多数现实世界的整数算术问题仍然可以用 32 位表示。对于大多数事情来说，40 亿是一个很大（足够）的数字。

因此，大概通过统计分析，您的编译器编写者决定在您的平台上，最有用的 int 大小是 32 位。对于 32 位算术（我们从第一天开始就需要），任何较小的都将是低效的，而任何较大的都会浪费空间/寄存器/内存/cpu 周期。

用 c++（和 c）表示整数文字会产生一个 int - 环境的自然算术大小。在今天，这几乎总是一个 32 位的值。

c++ 规范说两个整数相乘产生一个整数。如果没有，则将两个整数相乘将需要产生一个长整数。但是，乘以两个多头会产生什么？长长的？好的，这是可能的。现在，如果我们将它们相乘会怎样？长长长长？

就是这样。

int64_t x = 1 * 2; 将执行以下操作：

1. 取值为 1 的整数（32 位）。
2. 取值 2 的整数（32 位）。
3. 将它们相乘，将结果存储为整数。如果算术溢出，那就这样吧。那是你的瞭望台。
4. 将生成的整数（无论现在可能是什么）转换为 int64（可能在您的系统上为long int。

所以简而言之，不。在问题中的代码 sn-p 中，拼写至少一个操作数的类型没有捷径可走。当然，您可以指定文字。但不能保证您系统上的long long（LL 文字后缀）与int64_t 相同。如果你想要一个int64_t，并且你希望代码是可移植的，你必须把它拼出来。

物有所值：

在后 c++11 世界中，所有对额外按键和非 DRYness 的担忧都会消失：

绝对是 int64：

auto test = int64_t(2123123123) * 17;

绝对是长长的：

auto test = 2'123'123'123LL * 17;

肯定是 int64，肯定是用 long long 初始化（可能会变窄，但没关系）：

auto test = int64_t(36'093'093'091LL);

Answer 3

由于您很可能处于LP64 环境中，其中int 只有32 位，因此您必须小心表达式中的文字常量。最简单的方法是养成在文字常量上使用正确后缀的习惯，因此您可以将上面的内容写为：

int64_t test = 2123123123LL * 17LL;

Answer 4

2123123123 是 int（通常为 32 位）。

添加L 使其成为long：2123123123L（通常为32 位或64 位，即使在64 位模式下也是如此）。

添加另一个L 使其成为long long：2123123123LL（64 位或更多，从 C++11 开始）。

请注意，您只需将后缀添加到超出int 大小的常量。积分转换将负责产生正确的结果*。

(2123123123LL * 17)  // 17 is automatically converted to long long, the result is long long

* 但请注意：即使表达式中的单个常量适合 int，整个操作 仍然会像 in

那样溢出

(1024 * 1024 * 1024 * 10)

在这种情况下，您应该确保以足够的宽度执行算术（考虑运算符优先级）：

(1024LL * 1024 * 1024 * 10)

- 将以 64 位执行所有 3 个操作，结果为 64 位。

Answer 5

编辑：文字常量（A.K.A. 幻数）不受欢迎，因此最好的方法是使用符号常量（const int64_t value = 5）。有关更多信息，请参阅What is a magic number, and why is it bad?。 最好不要阅读此答案的其余部分，除非您出于某种奇怪的原因真的想使用幻数。

另外，您可以使用#include <cstdint> 中的intptr_t 和uintprt_t 让编译器选择是使用int 还是__int64。

对于那些偶然发现这个问题的人，数字末尾的“LL”可以解决问题，但不建议这样做，因为 Richard Hodges 告诉我，“long long”可能并不总是 64 位，并且可以增加未来的规模，尽管不太可能。有关更多信息，请参阅 Richard Hodge 的答案及其上的 cmets。

可靠的方法是将 `using QW = int_64t;` 放在顶部并使用 `QW(5)` 而不是 `5LL`。

我个人认为应该有一个选项来定义所有 64 位文字，而不必为其添加任何后缀或函数，并在必要时使用 `int32_t(5)`，因为某些程序不受此更改的影响。示例：仅使用数字进行正常计算，而不是依靠整数溢出来完成它的工作。问题是从 64 位到 32 位，而不是从 32 到 64 位，因为前 4 个字节被截断了。