c++ - 与指针相比，链式公共(public)成员访问的性能

Question

由于我找不到任何与链式成员访问有关的问题，但只有链式函数访问，所以我想问几个问题。

我有以下情况:

for(int i = 0; i < largeNumber; ++i)
{
  //do calculations with the same chained struct:
  //myStruct1.myStruct2.myStruct3.myStruct4.member1
  //myStruct1.myStruct2.myStruct3.myStruct4.member2
  //etc.
}

显然可以使用指针将其分解:

MyStruct4* myStruct4_pt = &myStruct1.myStruct2.myStruct3.myStruct4;
for(int i = 0; i < largeNumber; ++i)
{
  //do calculations with pointer:
  //(*myStruct4_pt).member1
  //(*myStruct4_pt).member2
  //etc.
}

成员访问 (.) 和函数访问(例如返回指向私有(private)变量的指针)之间有区别吗？

第一个示例是否/可以由编译器优化，这是否强烈依赖于编译器？

如果在编译期间没有进行优化，CPU 是否/可以优化行为(例如将其保存在 L1 缓存中)？

链式成员访问在性能方面有什么不同吗，因为无论如何在编译期间变量都会“疯狂地重新分配”？

我恳请不要讨论有关代码的可读性和可维护性的问题，因为对于我来说，链式访问更加清晰。

更新:一切都在一个线程中运行。

Answer 1

这是您要修改的常量偏移量，现代编译器会意识到这一点。

但是 - 不要相信我，让我们问问编译器(参见 here)。

#include <stdio.h>

struct D { float _; int i; int j; };

struct C { double _; D d; };

struct B { char _; C c; };

struct A { int _; B b; };

int bar(int i);
int foo(int i);

void foo(A &a) {
  for (int i = 0; i < 10; i++) {
    a.b.c.d.i += bar(i);
    a.b.c.d.j += foo(i);
  }
}

编译为

foo(A&):
    pushq   %rbp
    movq    %rdi, %rbp
    pushq   %rbx
    xorl    %ebx, %ebx
    subq    $8, %rsp
.L3:
    movl    %ebx, %edi
    call    bar(int)
    addl    %eax, 28(%rbp)
    movl    %ebx, %edi
    addl    $1, %ebx
    call    foo(int)
    addl    %eax, 32(%rbp)
    cmpl    $10, %ebx
    jne .L3
    addq    $8, %rsp
    popq    %rbx
    popq    %rbp
    ret

如您所见，在这两种情况下链接都已转换为单个偏移量:28(%rbp) 和 32(%rbp)。