C 访问结构中的字段是否需要更多时间？

访问结构中深层的字段需要额外的时间（汇编指令），还是编译器硬编码了这些内存位置？我想从逻辑上把某些东西放在一个结构中，但我想知道我是否会因此而受到性能的影响

例如，在以下代码中，写入

s.c.d

是否比写入

d2

慢

typedef struct a_struct_tag {
  uint8_t d;
} a_struct_t;

typedef struct my_struct_tag {
  uint8_t    a;
  uint8_t    b[8];
  a_struct_t c;
} my_struct_t;

int main()
{
 my_struct_t s;
 s.c.d = 3;

 a_struct_t d2;
 d2.d = 4;
}

---

没有区别。让我们从ObjDIP-S二进制< /代码>：

看一下汇编输出。

int main()
{
  40053c:       55                      push   %rbp
  40053d:       48 89 e5                mov    %rsp,%rbp
  400540:       48 83 ec 30             sub    $0x30,%rsp
  400544:       64 48 8b 04 25 28 00    mov    %fs:0x28,%rax
  40054b:       00 00 
  40054d:       48 89 45 f8             mov    %rax,-0x8(%rbp)
  400551:       31 c0                   xor    %eax,%eax
my_struct_t s;
s.c.d = 3;
  400553:       c6 45 e9 03             movb   $0x3,-0x17(%rbp)

a_struct_t d2;
d2.d = 4;
  400557:       c6 45 df 04             movb   $0x4,-0x21(%rbp)
}
 .... //the rest is not interesting, or at least I believe so

现在我不是x86汇编的专家，但我们可以清楚地看到，这两个命令只有一条指令

为什么会这样？如果您有一个结构，它是根据其大小明确定义的，那么在编译过程中可以计算每个偏移量。现在它只是“在存储单元Y中输入一个值X”

嵌套的级别并不重要

关于性能调整的一般指导原则，让我引用Donald Knuth：

过早优化是万恶之源

---

与其担心编译器的工作，不如优化算法和IO。如果您允许使用某些编译标志，编译器可以在优化方面创造奇迹（字面上！）。

没有区别。让我们从ObjDIP-S二进制< /代码>：

看一下汇编输出。

int main()
{
  40053c:       55                      push   %rbp
  40053d:       48 89 e5                mov    %rsp,%rbp
  400540:       48 83 ec 30             sub    $0x30,%rsp
  400544:       64 48 8b 04 25 28 00    mov    %fs:0x28,%rax
  40054b:       00 00 
  40054d:       48 89 45 f8             mov    %rax,-0x8(%rbp)
  400551:       31 c0                   xor    %eax,%eax
my_struct_t s;
s.c.d = 3;
  400553:       c6 45 e9 03             movb   $0x3,-0x17(%rbp)

a_struct_t d2;
d2.d = 4;
  400557:       c6 45 df 04             movb   $0x4,-0x21(%rbp)
}
 .... //the rest is not interesting, or at least I believe so

现在我不是x86汇编的专家，但我们可以清楚地看到，这两个命令只有一条指令

为什么会这样？如果您有一个结构，它是根据其大小明确定义的，那么在编译过程中可以计算每个偏移量。现在它只是“在存储单元Y中输入一个值X”

嵌套的级别并不重要

关于性能调整的一般指导原则，让我引用Donald Knuth：

过早优化是万恶之源

---

与其担心编译器的工作，不如优化算法和IO。如果您允许使用某些编译标志，编译器可以在优化方面创造奇迹（字面上！）。

没有区别。让我们从ObjDIP-S二进制< /代码>：

看一下汇编输出。

int main()
{
  40053c:       55                      push   %rbp
  40053d:       48 89 e5                mov    %rsp,%rbp
  400540:       48 83 ec 30             sub    $0x30,%rsp
  400544:       64 48 8b 04 25 28 00    mov    %fs:0x28,%rax
  40054b:       00 00 
  40054d:       48 89 45 f8             mov    %rax,-0x8(%rbp)
  400551:       31 c0                   xor    %eax,%eax
my_struct_t s;
s.c.d = 3;
  400553:       c6 45 e9 03             movb   $0x3,-0x17(%rbp)

a_struct_t d2;
d2.d = 4;
  400557:       c6 45 df 04             movb   $0x4,-0x21(%rbp)
}
 .... //the rest is not interesting, or at least I believe so

现在我不是x86汇编的专家，但我们可以清楚地看到，这两个命令只有一条指令

为什么会这样？如果您有一个结构，它是根据其大小明确定义的，那么在编译过程中可以计算每个偏移量。现在它只是“在存储单元Y中输入一个值X”

嵌套的级别并不重要

关于性能调整的一般指导原则，让我引用Donald Knuth：

过早优化是万恶之源

---

与其担心编译器的工作，不如优化算法和IO。如果您允许使用某些编译标志，编译器可以在优化方面创造奇迹（字面上！）。

没有区别。让我们从ObjDIP-S二进制< /代码>：

看一下汇编输出。

int main()
{
  40053c:       55                      push   %rbp
  40053d:       48 89 e5                mov    %rsp,%rbp
  400540:       48 83 ec 30             sub    $0x30,%rsp
  400544:       64 48 8b 04 25 28 00    mov    %fs:0x28,%rax
  40054b:       00 00 
  40054d:       48 89 45 f8             mov    %rax,-0x8(%rbp)
  400551:       31 c0                   xor    %eax,%eax
my_struct_t s;
s.c.d = 3;
  400553:       c6 45 e9 03             movb   $0x3,-0x17(%rbp)

a_struct_t d2;
d2.d = 4;
  400557:       c6 45 df 04             movb   $0x4,-0x21(%rbp)
}
 .... //the rest is not interesting, or at least I believe so

现在我不是x86汇编的专家，但我们可以清楚地看到，这两个命令只有一条指令

为什么会这样？如果您有一个结构，它是根据其大小明确定义的，那么在编译过程中可以计算每个偏移量。现在它只是“在存储单元Y中输入一个值X”

嵌套的级别并不重要

关于性能调整的一般指导原则，让我引用Donald Knuth：

过早优化是万恶之源

---

与其担心编译器的工作，不如优化算法和IO。如果您允许使用某些编译标志，编译器可以在优化方面创造奇迹（字面上！）。

为什么不查看输出程序集？此外，您还可以自己运行一些简单的测试。我怀疑这里的任何性能差异“节省”（如果有的话）是否会超过任何IO/数据库/网络调用或复杂的数学运算。为什么不看看输出程序集呢？此外，您还可以自己运行一些简单的测试。我怀疑这里的任何性能差异“节省”（如果有的话）是否会超过任何IO/数据库/网络调用或复杂的数学运算。为什么不看看输出程序集呢？此外，您还可以自己运行一些简单的测试。我怀疑这里的任何性能差异“节省”（如果有的话）是否会超过任何IO/数据库/网络调用或复杂的数学运算。为什么不看看输出程序集呢？此外，您还可以自己运行一些简单的测试。我怀疑这里的任何性能差异“节省”（如果有的话）是否会超过任何IO/数据库/网络调用或复杂的数学计算。