blocks|key|20532|text|结构类型的对象的地址总是等于对象的第一个成员的地址。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|20533|来自C标准(6.7.2.1结构和联合说明)|20534|15在结构对象中，非位字段成员和位字段所在的单元具有按声明顺序增加的地址。指向结构对象的指针，经过适当的转换，指向它的初始成员(或者如果该成员是位字段，则指向它所在的单元)，反之亦然。结构对象中可能有未命名的填充，但在结构对象的开头可能没有。。|blockquote|offset|length|style|BOLD|20535|这里有一个演示程序|20536|#include+<stdio.h>

int+main(void)+
{
++++struct+abc
++++{
++++++++char+a;
++++++++char+b;
++++++++int+c;
++++}+abc+=+{+'A',+'B',+3+};
++++
++++printf(+"&abc+=+%25p,+&abc.a+=+%25p\n",+(+void+*+)&abc,+(+void+*+)&abc.a+);
++++
++++struct+abc+*p+=+&abc;
++++
++++printf(+"*(+char+*+)p+=+%25c\n",+*(+char+*+)p+);
++++
++++return+0;
}|code-block|syntax|javascript|20537|程序输出可能类似于|20538|&abc+=+0x7ffe8cfad6c0,+&abc.a+=+0x7ffe8cfad6c0
*(+char+*+)p+=+A|20539|entityMap^0|0|0|11|2C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Z|8|@$G|10|H|11|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|13|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|14|8|@]|9|@]|A|$]]|$1|T|3|U|5|O|7|15|8|@]|9|@]|A|$P|Q]]|$1|V|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|W|$]]

The address of an object of a structure type is always equal to the address of the first member of the object.
From the C Standard (6.7.2.1 Structure and union specifiers)
<blockquote>
15 Within a structure object, the non-bit-field members and the units
in which bit-fields reside have addresses that increase in the order
in which they are declared. A pointer to a structure object,
suitably converted, points to its initial member (or if that member is
a bit-field, then to the unit in which it resides), and vice versa.
There may be unnamed padding within a structure object, but not at its
beginning.
</blockquote>
Here is a demonstrative program
<pre><code>#include &lt;stdio.h&gt;

int main(void) 
{
 struct abc
 {
 char a;
 char b;
 int c;
 } abc = { 'A', 'B', 3 };
 
 printf( &quot;&amp;abc = %p, &amp;abc.a = %p\n&quot;, ( void * )&amp;abc, ( void * )&amp;abc.a );
 
 struct abc *p = &amp;abc;
 
 printf( &quot;*( char * )p = %c\n&quot;, *( char * )p );
 
 return 0;
}
</code></pre>
The program output might look like
<pre><code>&amp;abc = 0x7ffe8cfad6c0, &amp;abc.a = 0x7ffe8cfad6c0
*( char * )p = A
</code></pre>

blocks|key|20590|text|这是编译器进行的优化，因为它对CPU来说更容易。大多数编译器应该允许您禁用它。例如，在GCC中你可以使用__attribute__((packed))。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|20591|也见如何覆盖C编译器将结构中的字大小变量对齐到word边界。|20592|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/30923228/how-to-override-c-compiler-aligning-word-sized-variable-in-struct-to-word-bounda^0|1G|N|0|2|R|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@$9|T|A|U|1|V]]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

This is an optimization the compiler makes because it's easier for the CPU. Most compilers should allow you to disable it. For example, in GCC you can use <code>__attribute__((packed))</code>.
Also see <a href="https://stackoverflow.com/questions/30923228/how-to-override-c-compiler-aligning-word-sized-variable-in-struct-to-word-bounda">How to override C compiler aligning word-sized variable in struct to word boundary</a>.

blocks|key|20632|text|然而，这确实是建立在这样的假设之上，即struct的第一个成员将在word边界之后立即存储。总是这样吗？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|20633|是。|unstyled|20634|当定义了结构类型时，结构的对准要求至少是其成员的最严格的对准要求。例如，如果结构的成员对齐要求为1字节、8字节和4字节，则结构的对齐要求为8字节。当定义结构时，编译器将自动计算出这一点。(从技术上讲，C标准可能允许编译器对结构进行更大的对齐-我没有看到任何反对它的规则-但在实践中并没有这样做。)|20635|然后，每当C实现为结构对象保留内存时(就像定义该类型的对象(例如struct+foo+x)一样)，它将确保该结构所需的内存是对齐的。这也会使成员的调整要求得到满足。当程序用malloc分配内存时，返回的内存总是根据需要对齐所请求大小的任何对象。|offset|length|style|CODE|20636|(如果您在程序中做了任何“有趣的事情”来为对象设置自己的内存位置，比如在分配给malloc的内存中放置一个，那么您应该负责正确地对齐。)|20637|此外，如果有必要，结构将在末尾填充，使其总大小是该对齐要求的倍数。然后，在这些结构的数组中，数组的每个连续元素也将开始于一个正确对齐的位置。|20638|entityMap^0|0|0|0|W|C|2E|6|0|13|6|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|U|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|V|8|@$I|W|J|X|K|L]|$I|Y|J|Z|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|O|3|P|5|D|7|13|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|D|7|14|8|@]|9|@]|A|$]]]|R|$]]

<blockquote>
However, this does build on the assumption that the first member of struct will be stored immediately after word boundary. Is it always so?
</blockquote>
Yes.
When a structure type is defined, the alignment requirement of the structure will be at least the strictest alignment requirement of its members. For example, if a structure has members with alignment requires of 1 byte, 8 bytes, and 4 bytes, the alignment requirement of the structure will be 8 bytes. The compiler will figure this out automatically when the structure is defined. (Technically, the C standard might permit the compiler to give the structure an even greater alignment—I do not see any rule against it—but that is not done in practice.)
Then, whenever the C implementation reserves memory for a structure object (as when you define an object of that type, such as <code>struct foo x</code>), it will ensure the memory is aligned as required for that structure. That results in the alignment requirements of the members being satisfied too. When a program allocates memory with <code>malloc</code>, the returned memory is always aligned as necessary for any object of the requested size.
(If you do any “funny stuff” in a program to set your own memory locations for objects, such as placing one in the middle of memory allocated with <code>malloc</code>, you are responsible for getting the alignment right.)
Further, the structure will be padded at the end if necessary so that its total size is a multiple of that alignment requirement. Then, in an array of those structures, each successive element of the array will begin at a properly aligned location too.

I was learning about struct padding in C and came across <a href="https://www.youtube.com/watch?v=aROgtACPjjg&amp;t=202s" rel="nofollow noreferrer">this video</a>.
Basically it says if I have a struct
<pre><code>struct abc {
 char a; // 1 byte
 char b; // 1 byte
 int c; // 4 bytes
} var;
</code></pre>
Then, instead of storing the struct like this (c,...,c denote the four bytes of c; || is the word boundary; _ is a place for byte)
<pre><code>_ _ _ _ || _ _ _ _
a b c c c c 
</code></pre>
Two bytes of empty space will be padded after b, resulting in (e denotes empty)
<pre><code>_ _ _ _ || _ _ _ _
a b e e c c c c
</code></pre>
So that the CPU can get int c in one CPU cycle.
<blockquote>
However, this does build on the assumption that the first member (a in my case) of struct will be stored immediately after word boundary. Is it always so?
</blockquote>

Assumption of structure padding in C

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我当时正在学习C语言中的struct填充，并偶然发现了。基本上它说如果我有一个结构struct abc {    char a;    // 1 byte    char b;    // 1 byte    int c;     // 4 bytes} var;然后，而不是像这样存储结构(c，.，c表示c的四个字节；...

问C语言中结构填充的假设
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C语言中结构填充的假设EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C语言中结构填充的假设
EN