在 C++ 中确定 32 位与 64 位
我正在寻找一种方法来可靠地确定 C++ 代码是否以 32 位与 64 位进行编译。我们已经提出了我们认为使用宏的合理解决方案，但很想知道人们是否能想到可能失败的情况，或者是否有更好的方法来做到这一点。请注意，我们正在尝试在跨平台、多编译器环境中执行此操作。
#if ((ULONG_MAX) == (UINT_MAX))
# define IS32BIT
#else
# define IS64BIT
#endif
#ifdef IS64BIT
DoMy64BitOperation()
#else
DoMy32BitOperation()
#endif
谢谢。
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（16）
不幸的是，没有跨平台宏可以跨主要编译器定义 32 / 64 位。我发现最有效的方法如下。
首先我选择自己的代表。我更喜欢 ENVIRONMENT64 / ENVIRONMENT32。然后我找出所有主要编译器使用什么来确定它是否是 64 位环境，并使用它来设置我的变量。
另一种更简单的方法是简单地从编译器命令行设置这些变量。
Unfortunately there is no cross platform macro which defines 32 / 64 bit across the major compilers. I've found the most effective way to do this is the following.
First I pick my own representation. I prefer ENVIRONMENT64 / ENVIRONMENT32. Then I find out what all of the major compilers use for determining if it's a 64 bit environment or not and use that to set my variables.
Another easier route is to simply set these variables from the compiler command line.
不幸的是，在跨平台、跨编译器环境中，没有单一可靠的方法可以纯粹在编译时执行此操作。
因此，唯一可靠的方法是结合3个简单检查：
简单检查1/3：编译时设置
选择任意方法来设置所需的#define变量。我建议使用 @JaredPar 中的方法：
简单检查 2/3：运行时检查
在 main() 中，仔细检查 sizeof() 是否有意义：
简单检查 3/3：强大的编译时检查
一般规则是“每个 #define必须以 #else 结尾，这会生成错误”。
2017-01-17 更新
来自
@AI.G的评论：附录 A
顺便说一句，可以调整上述规则以使整个代码库更加可靠：
这种方法之所以有效，是因为它迫使您提前考虑每种情况，而不是依赖“else”部分中的（有时是有缺陷的）逻辑来执行正确的代码。
我使用这种技术（以及其他许多技术）编写了一个 30,000 行的项目，该项目从首次部署到生产中（即 12 个月前）之日起就完美运行。
Unfortunately, in a cross platform, cross compiler environment, there is no single reliable method to do this purely at compile time.
Therefore, the only reliable method is to combine 3 simple checks:
Simple check 1/3: Compile time setting
Choose any method to set the required #define variable. I suggest the method from @JaredPar:
Simple check 2/3: Runtime check
In main(), double check to see if sizeof() makes sense:
Simple check 3/3: Robust compile time checking
The general rule is "every #define must end in a #else which generates an error".
Update 2017-01-17
Comment from
@AI.G:Appendix A
Incidentially, the rules above can be adapted to make your entire codebase more reliable:
The reason why this works well is that it forces you to think of every single case in advance, and not rely on (sometimes flawed) logic in the "else" part to execute the correct code.
I used this technique (among many others) to write a 30,000 line project that worked flawlessly from the day it was first deployed into production (that was 12 months ago).
您应该能够使用
stdint.h< 中定义的宏/代码>。特别是INTPTR_MAX正是您需要的值。某些（所有？）版本的 Microsoft 编译器不附带
stdint.h。不知道为什么，因为它是标准文件。您可以使用以下版本：http://msinttypes.googlecode.com/svn/trunk/stdint.hYou should be able to use the macros defined in
stdint.h. In particularINTPTR_MAXis exactly the value you need.Some (all?) versions of Microsoft's compiler don't come with
stdint.h. Not sure why, since it's a standard file. Here's a version you can use: http://msinttypes.googlecode.com/svn/trunk/stdint.h一开始这在 Windows 上是行不通的。无论您是针对 32 位还是 64 位窗口进行编译，长整型和整数都是 32 位。我认为检查指针的大小是否为 8 字节可能是更可靠的路线。
That won't work on Windows for a start. Longs and ints are both 32 bits whether you're compiling for 32 bit or 64 bit windows. I would think checking if the size of a pointer is 8 bytes is probably a more reliable route.
你可以这样做：
You could do this:
下面的代码适用于大多数当前环境：
Below code works fine for most current environments:
“以 64 位编译”在 C++ 中没有明确定义。
C++ 仅对 int、long 和
void *等大小设置下限。即使为 64 位平台编译，也不能保证 int 是 64 位。该模型允许例如 23 位int和sizeof(int *) != sizeof(char *)有不同的 64 位平台的编程模型。
最好的选择是特定于平台的测试。您的次优、可移植决策必须更具体地说明什么是 64 位。
"Compiled in 64 bit" is not well defined in C++.
C++ sets only lower limits for sizes such as int, long and
void *. There is no guarantee that int is 64 bit even when compiled for a 64 bit platform. The model allows for e.g. 23 bitints andsizeof(int *) != sizeof(char *)There are different programming models for 64 bit platforms.
Your best bet is a platform specific test. Your second best, portable decision must be more specific in what is 64 bit.
您的方法并不太遥远，但您只是检查
long和int的大小是否相同。理论上，它们可能都是 64 位，在这种情况下，假设两者都是 32 位，您的检查将会失败。下面的检查实际上检查类型本身的大小，而不是它们的相对大小：原则上，您可以对具有最大值的系统定义宏的任何类型执行此操作。
请注意，该标准要求 long long 至少为 64 位，即使在 32 位系统上也是如此。
Your approach was not too far off, but you are only checking whether
longandintare of the same size. Theoretically, they could both be 64 bits, in which case your check would fail, assuming both to be 32 bits. Here is a check that actually checks the size of the types themselves, not their relative size:In principle, you can do this for any type for which you have a system defined macro with the maximal value.
Note, that the standard requires
long longto be at least 64 bits even on 32 bit systems.借鉴了 Contango 的优秀上面的答案并将其与“更好的宏相结合, Better Flags" 来自 Fluent C++，你可以这样做：
然后你可以像这样使用它：
或者使用我添加的额外宏：
Borrowing from Contango's excellent answer above and combining it with "Better Macros, Better Flags" from Fluent C++, you can do:
Then you can use it like:
Or using the extra macro I added:
人们已经提出了一些方法来尝试确定程序是否以 32 位或 64 位编译。
我想补充一点，您可以使用 c++11 功能
static_assert来确保架构符合您的想法（“放松”）。所以在你定义宏的地方：
People already suggested methods that will try to determine if the program is being compiled in
32-bitor64-bit.And I want to add that you can use the c++11 feature
static_assertto make sure that the architecture is what you think it is ("to relax").So in the place where you define the macros:
这里还有一些方法可以在现代 C++ 中实现您想要的功能。
您可以创建一个定义系统位数的变量：
然后在 C++17 中您可以执行以下操作：
或者在 C++20 中：
template<...>通常是不需要，但由于这些函数将具有相同的修饰名称，因此我们必须强制编译器选择正确的函数。另外，template可能会令人困惑（另一个模板可能更好并且逻辑上更正确），我仅将其用作满足编译器名称修改的解决方法。Here are a few more ways to do what you want in modern C++.
You can create a variable that defines the number of system bits:
And then in C++17 you can do something like:
Or in C++20:
The
template<...>is usually not needed, but since those functions will have the same mangling name, we must enforce the compiler to pick the correct ones. Also,template<void* = nullptr>may be confusing ( The other template may be better and more logically correct ), I only used it as a workaround to satisfy the compiler name mangling.如果您可以在所有环境中使用项目配置，则可以轻松定义 64 位和 32 位符号。所以你会有这样的项目配置：
32位调试
32 位版本
64位调试
64 位版本
编辑：这些是通用配置，而不是目标配置。你想怎么称呼他们就怎么称呼他们。
如果你做不到，我喜欢贾里德的想法。
If you can use project configurations in all your environments, that would make defining a 64- and 32-bit symbol easy. So you'd have project configurations like this:
32-bit Debug
32-bit Release
64-bit Debug
64-bit Release
EDIT: These are generic configurations, not targetted configurations. Call them whatever you want.
If you can't do that, I like Jared's idea.
我会将 32 位和 64 位源放在不同的文件中，然后使用构建系统选择适当的源文件。
I'd place 32-bit and 64-bit sources in different files and then select appropriate source files using the build system.
我将此答案添加为另一个答案中描述的运行时检查的用例和完整示例。
这是我一直在向最终用户传达程序是编译为 64 位还是 32 位（或其他位，就此而言）的方法：
version.h
test.cc
编译并测试
I'm adding this answer as a use case and complete example for the runtime-check described in another answer.
This is the approach I've been taking for conveying to the end-user whether the program was compiled as 64-bit or 32-bit (or other, for that matter):
version.h
test.cc
Compile and Test