C语言sizeof()函数是否依赖主机？跨编译能否解决结构体大小差异问题？

Great question—this is a super common pitfall when writing cross-platform C code, so let’s break this down step by step:

1. Does sizeof() depend on the host machine? #

Absolutely. sizeof() is primarily a compile-time operator (with rare exceptions for variable-length arrays), and its result hinges entirely on the target compilation environment, which includes:

• CPU architecture (e.g., 32-bit vs 64-bit, x86 vs ARM)
• The operating system’s ABI (Application Binary Interface), which defines mandatory memory alignment rules
• Compiler-specific defaults and settings (e.g., GCC and MSVC have different default alignment behaviors for structs)
• Basic data type sizes (the C standard doesn’t fix sizes for types like int—it’s 2 bytes on 16-bit systems, 4 bytes on most modern 32/64-bit systems, but this isn’t universal)

2. Will the struct size change when compiled on another OS? #

It very likely will, unless you explicitly enforce consistency. For example:

• If you have a struct like struct Foo { char flag; int value; };, Linux with GCC (default 4-byte alignment) will pad it to 8 bytes (1 byte for char, 3 bytes of padding to align int to a 4-byte boundary, plus 4 bytes for int). On Windows with MSVC (default 8-byte alignment for structs containing 32-bit+ types), this same struct might end up as 16 bytes if paired with other types.
• Even simpler structs can vary: a struct holding just an int will be 2 bytes on a 16-bit embedded system, but 4 bytes on most desktop OSes.

Without explicit controls, moving compilation to another OS (or even switching compilers on the same OS) can easily alter the struct’s size.

3. Can cross-compiling fix this? #

Cross-compiling itself doesn’t guarantee consistency—but it lets you enforce it if configured correctly. Cross-compiling means building code on your Linux host for a different target platform (e.g., Windows, ARM). To match your original 4-byte struct size:

• Match the target architecture and ABI of your original Linux build. For example, if your original build was for 32-bit x86, use GCC’s -m32 flag when cross-compiling for the target OS.
• Explicitly set alignment rules. Use directives like __attribute__((packed)) (GCC/clang) or #pragma pack(push, 4) (works across GCC/MSVC) to enforce a fixed alignment size and eliminate unexpected padding.
• Replace platform-dependent types with fixed-size alternatives from <stdint.h> (e.g., use uint32_t instead of int) to avoid relying on default type sizes.

If you follow these steps, cross-compiling will produce a binary where the struct size matches your original Linux result, even when deployed to another OS. But if you cross-compile without matching these settings, the struct size could still differ.

内容的提问来源于stack exchange，提问作者avan989