blocks|key|5127238|text|通常，插入填充是为了允许对结构的内部元素进行对齐访问，而不是允许整个结构是多个字的大小。对齐是一个编译器实现问题，而不是C标准的要求。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5127239|因此，长度为3个字节的char元素不需要对齐，因为它们是字节元素。|5127240|虽然不是必需的，但最好是短元素需要在短边界上对齐--这意味着偶数地址。通过在短边界上对齐，编译器可以发出单个加载短指令，而不必加载一个字、掩码，然后移位。|5127241|在这种情况下，填充可能发生在末尾而不是中间。您必须编写代码来转储元素的地址，以确定填充发生的位置。|5127242|编辑：。正如@Euguen+Sh提到的，即使你发现了编译器用于结构的填充方案，编译器也可以在不同版本的编译器中修改它。|5127243|依赖编译器的填充方案是不明智的。总有一些方法可以以这样一种方式访问元素，使您不会猜测对齐。|5127244|sizeof()运算符用于查看使用了多少内存，以及如果指针递增1+(ptr%2B%2B)，将向结构的ptr添加多少内存。|5127245|EDIT+2，打包：可以打包结构，以防止使用__packed__属性进行填充。在设计结构时，明智的做法是使用自然包装的元素。当通过通信链路发送数据时，这一点尤其重要。精心设计的结构避免了在结构中间填充的需要。随后使用__packed__属性编译的设计不佳的结构可能具有不自然对齐的内部元素。人们可以这样做，以确保该结构将像最初设计的那样通过导线传输。随着通过线路传输数据的JSON的引入，这种类型的工作已经减少。|CODE|5127246|entityMap^0|5|A|0|0|0|0|0|3|0|0|0|0|9|M|A|30|A|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|11|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|15|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|16|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|T]|$9|1C|A|1D|B|T]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|V|$]]

Generally, padding is inserted to allow for aligned access of the internal elements of the structure, not to allow the entire structure to be a size of multiple words. Alignment is a compiler implementation issue, not a requirement of the C standard.

So, the char elements which are 3 bytes in length, need no alignment because they are byte elements.

It is preferred, though not required, that the short element needs to be aligned on a short boundary -- which means an even address. By aligning it on a short boundary, the compiler can issue a single load short instruction rather than having to load a word, mask, and then shift.

In this case, the padding is probably, but not necessarily, happening at the end rather than in the middle. You will have to write code to dump the address of the elements to determine where padding is taking place.

EDIT: . As @Euguen Sh mentions, even if you discover the padding scheme that the compiler is using for the structure, the compiler could modify that in a different version of the compiler. 

It is unwise to count on the padding scheme of the compiler. There are always methods to access the elements in such a way that you do not guess at alignments. 

The sizeof() operator is used to allow you to see how much memory is used AND to know how much will be added to a ptr to the structure if that pointer is incremented by 1 (ptr++). 

EDIT 2, Packing: Structures may be packed to prevent padding using the <code>__packed__</code> attribute. When designing a structure, it is wise to use elements that naturally pack. This is especially important when sending data over a communications link. A carefully designed structure avoids the need for padding in the middle of the strucuture. A poorly designed structure which is then compiled with the <code>__packed__</code> attribute may have internal elements that are not naturally aligned. One might do this to ensure that the structure will transmit across a wire as it was originally designed. This type of effort has diminished with the introduction of JSON for transmission of data over a wire.

blocks|key|1859531|text|#include+<stdalign.h>
#include+<assert.h>|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1859532|结构的大小总是可以被成员的最大对齐整除(必须是2的幂)。如果你有一个带有char和short的结构，对齐是2，因为short的对齐是2，如果你有一个结构，只有在char中它的对齐是1。|unstyled|offset|length|style|CODE|1859533|有多种方法可以操作对齐方式：|1859534|alignas(4)+char[4];+//+this+can+hold+32-bit+ints|1859535|这是非标准的，但在大多数编译器(GCC，Clang，...)中都可用：|1859536|struct+A+{
++++char+a;
++++short+b;
};

struct+__attribute__((packed))+B+{
++++char+a;
++++short+b;
};

static_assert(sizeof(struct+A)+==+4);
static_assert(alignof(struct+A)+==+2);

static_assert(sizeof(struct+B)+==+3);
static_assert(alignof(struct+B)+==+1);|1859537|entityMap^0|0|10|4|15|5|1L|5|28|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@$G|W|H|X|I|J]|$G|Y|H|Z|I|J]|$G|10|H|11|I|J]|$G|12|H|13|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$B|C]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$B|C]]|$1|S|3|-4|5|F|7|18|8|@]|9|@]|A|$]]]|T|$]]

<pre><code>#include &lt;stdalign.h&gt;
#include &lt;assert.h&gt;
</code></pre>

The size of a struct is always divisible by the maximum alignment of the members (which must be a power of two). 
If you have a struct with <code>char</code> and <code>short</code> the alignment is 2, because the alignment of <code>short</code> is two, if you have a struct, only out of <code>char</code>s it has an alignment of 1.

There are multiple ways to manipulate the alignment:

<pre><code>alignas(4) char[4]; // this can hold 32-bit ints
</code></pre>

This is nonstandart, but available in most compilers (GCC, Clang, ...):

<pre><code>struct A {
 char a;
 short b;
};

struct __attribute__((packed)) B {
 char a;
 short b;
};

static_assert(sizeof(struct A) == 4);
static_assert(alignof(struct A) == 2);

static_assert(sizeof(struct B) == 3);
static_assert(alignof(struct B) == 1);
</code></pre>

blocks|key|5127306|text|通常，编译器遵循目标体系结构的ABI。它定义了结构和原始数据类型的对齐方式。这会影响到所需的填充和结构的大小。因为在许多架构中对齐是4的倍数，所以结构的大小也是如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5127307|编译器可能会提供一些属性/选项来或多或少地直接更改对齐。|5127308|例如，gcc和clang提供：__attribute__+((packed))|offset|length|style|CODE|5127309|entityMap^0|0|0|F|O|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@$F|O|G|P|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Usually compilers follow ABI of the target architecture. 
It defines alignments of structures and primitive datatypes. And that affects to needed padding and sizes of structures. Because alignment is multiple of 4 in many architectures, size of structures are too.

Compilers may offer some attributes/options for changing alignments more or less directly. 

For example gcc and clang offers: <code>__attribute__ ((packed))</code>

I'm new to structures and was learning how to find the size of structures. I'm aware of how padding comes in to play in order to properly align the memory. From what I've understood, the alignment is done so that the size in memory comes out to be a multiple of 4.
I tried the following piece of code on GCC.

<pre><code>struct books{
 short int number;
 char name[3];
}book;
printf("%lu",sizeof(book));
</code></pre>

Initially I had thought that the short int would occupy 2 bytes, followed by the character array starting at the third memory location from the beginning. The character array then would need a padding of 3 bytes which would give a size of 8. Something like this, where each word represents a byte in memory.

short short char char

char padding padding padding 

However on running it gives a size of 6, which confuses me. 

Any help would be appreciated, thanks!

How can size of a structure be a non-multiple of 4?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我刚接触结构，正在学习如何找到结构的大小。我知道填充是如何发挥作用的，以便正确地对齐内存。struct books{  short int number;  char name[3];}book;printf("%lu",sizeof(book));最初，我认为短的int会占用2个字节，然后是从第三个内存位置开始的字符...

问结构的大小怎么可能是4的非倍数？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问结构的大小怎么可能是4的非倍数？EN