从编译器的角度来看，数组的引用是如何处理的，为什么不允许按值传递（而不是衰减）？

Question

我们知道，在C语言中，我们可以将数组的引用作为参数传递，比如f（int）(

然后我写了一个演示，希望从汇编语言中看到一些东西：

void foo_p(int*arr) {}
void foo_r(int(&arr)[3]) {}
template<int length>
void foo_t(int(&arr)[length]) {}
int main(int argc, char** argv)
{
    int arr[] = {1, 2, 3};
    foo_p(arr);
    foo_r(arr);
    foo_t(arr);
   return 0;
}

最初，我猜它仍然会衰减到指针，但是会通过寄存器隐式传递长度，然后在函数体中变回数组。但是汇编代码告诉我这不是真的

void foo_t<3>(int (&) [3]):
  push rbp #4.31
  mov rbp, rsp #4.31
  sub rsp, 16 #4.31
  mov QWORD PTR [-16+rbp], rdi #4.31
  leave #4.32
  ret #4.32

foo_p(int*):
  push rbp #1.21
  mov rbp, rsp #1.21
  sub rsp, 16 #1.21
  mov QWORD PTR [-16+rbp], rdi #1.21
  leave #1.22
  ret #1.22

foo_r(int (&) [3]):
  push rbp #2.26
  mov rbp, rsp #2.26
  sub rsp, 16 #2.26
  mov QWORD PTR [-16+rbp], rdi #2.26
  leave #2.27
  ret #2.27

main:
  push rbp #6.1
  mov rbp, rsp #6.1
  sub rsp, 32 #6.1
  mov DWORD PTR [-16+rbp], edi #6.1
  mov QWORD PTR [-8+rbp], rsi #6.1
  lea rax, QWORD PTR [-32+rbp] #7.15
  mov DWORD PTR [rax], 1 #7.15
  lea rax, QWORD PTR [-32+rbp] #7.15
  add rax, 4 #7.15
  mov DWORD PTR [rax], 2 #7.15
  lea rax, QWORD PTR [-32+rbp] #7.15
  add rax, 8 #7.15
  mov DWORD PTR [rax], 3 #7.15
  lea rax, QWORD PTR [-32+rbp] #8.5
  mov rdi, rax #8.5
  call foo_p(int*) #8.5
  lea rax, QWORD PTR [-32+rbp] #9.5
  mov rdi, rax #9.5
  call foo_r(int (&) [3]) #9.5
  lea rax, QWORD PTR [-32+rbp] #10.5
  mov rdi, rax #10.5
  call void foo_t<3>(int (&) [3]) #10.5
  mov eax, 0 #11.11
  leave #11.11
  ret #11.11

现场演示

我承认我不熟悉汇编语言，但很明显，这三个函数的汇编代码是相同的！所以，在汇编程序编码之前一定会发生一些事情。总之，与数组不同，指针对长度一无所知，对吗？

1. 编译器在这里是如何工作的
2. 既然标准允许通过引用传递数组，这是否意味着实现起来很简单？如果是这样，为什么不允许按值传递

_{对于Q2，我的猜测是前C和C代码的复杂性。毕竟，函数参数中的int[]等于int*一直是一个传统。也许一百年后，它会被弃用}




Answer 1

关于：

我承认我不熟悉汇编语言，但很明显，这三个函数的汇编代码是一样的！

汇编代码可能是相同的，也可能是不同的——这取决于单个的C实现（以及您调用它们的选项）。只要保持可观察的行为（这是仔细定义的），C标准有一个总体的假设规则来允许任何生成的机器代码。

在你的问题中，不同的语法只是源代码级别和翻译过程中的语法和一些语义差异。它们中的每一个在标准中都有不同的定义——例如函数参数的确切类型会不同（如果你要使用像提升::type_index

Answer 2

这都是关于向后兼容性的。C从C获得数组，C从B语言获得数组。在B中，数组变量实际上是指针。丹尼斯·里奇写过这篇文章。

数组参数衰减为指针帮助Ken Thompson在将UNIX迁移到C时重用了他以前的B源代码

后来，人们认为这可能不是最好的决定，但却认为改变C语言为时已晚。因此，数组的衰减被保留，但后来添加的结构是按值传递的。

结构的引入也为您真正想要按值传递数组的情况提供了一种变通方法：

为什么在C中声明一个只包含数组的结构？

Answer 3

甚至C99intfoo（intarr[static 3]）在asm中仍然只是一个指针。static语法向编译器保证，即使C抽象机不访问某些元素，它也可以安全地读取所有3个元素，因此，例如，它可以使用无分支的cmov作为if。

调用方不会在寄存器中传递长度，因为它是编译时常量，因此在运行时不需要。

可以按值传递数组，但前提是数组位于结构或联合内部。在这种情况下，不同的呼叫约定有不同的规则。根据AMD64 ABI，数组是什么样的C11数据类型。

你几乎不想通过值传递数组，所以C没有语法是有道理的，C也从来没有发明过语法。通过常量引用（即const int*arr）传递要高效得多；只有一个指针arg。

我将您的代码放在Godbolt编译器资源管理器上，使用gcc-O3-fno内联函数进行编译-fno内联函数调用一次-fno内联小函数来阻止它内联函数调用。这消除了-O0调试构建和帧指针样板文件中的所有噪音。（我只是在手册页上搜索了内联，并禁用了内联选项，直到得到我想要的。）

您可以在函数定义上使用GNU C\uuuu attribute\uuu（（noinline））来禁用特定函数的内联，即使它们是静态的。

我还添加了对没有定义的函数的调用，因此编译器需要在内存中具有正确值的arr[]，并在其中两个函数的arr[4]中添加了一个存储。这让我们可以测试编译器是否警告超出数组边界。

__attribute__((noinline, noclone)) 
void foo_p(int*arr) {(void)arr;}
void foo_r(int(&arr)[3]) {arr[4] = 41;}

template<int length>
void foo_t(int(&arr)[length]) {arr[4] = 42;}

void usearg(int*); // stop main from optimizing away arr[] if foo_... inline

int main()
{
    int arr[] = {1, 2, 3};
    foo_p(arr);
    foo_r(arr);
    foo_t(arr);
    usearg(arr);
   return 0;
}

gcc7。3-O3-Wall-Wextra不带函数内联，在Godbolt上：由于我关闭了代码中未使用的args警告，我们得到的唯一警告是来自模板，而不是来自foo_r：

<source>: In function 'int main()':
<source>:14:10: warning: array subscript is above array bounds [-Warray-bounds]
     foo_t(arr);
     ~~~~~^~~~~

asm输出为：

void foo_t<3>(int (&) [3]) [clone .isra.0]:
    mov     DWORD PTR [rdi], 42       # *ISRA.3_4(D),
    ret
foo_p(int*):
    rep ret
foo_r(int (&) [3]):
    mov     DWORD PTR [rdi+16], 41    # *arr_2(D),
    ret

main:
    sub     rsp, 24             # reserve space for the array and align the stack for calls
    movabs  rax, 8589934593     # this is 0x200000001: the first 2 elems
    lea     rdi, [rsp+4]
    mov     QWORD PTR [rsp+4], rax    # MEM[(int *)&arr],  first 2 elements
    mov     DWORD PTR [rsp+12], 3     # MEM[(int *)&arr + 8B],  3rd element as an imm32
    call    foo_r(int (&) [3])
    lea     rdi, [rsp+20]
    call    void foo_t<3>(int (&) [3]) [clone .isra.0]    #
    lea     rdi, [rsp+4]      # tmp97,
    call    usearg(int*)     #
    xor     eax, eax  #
    add     rsp, 24   #,
    ret

对foo_p（）的调用仍然得到了优化，可能是因为它没有做任何事情。（我没有禁用过程间优化，甚至noinline和noclone属性也没有阻止这一点。）添加*arr=0对函数体的结果是从main调用函数体（在rdi中传递一个指针，就像其他2个一样）。

注意去映射函数名上的clone. ras.0注释：gcc定义了一个函数，该函数的指针指向arr[4]，而不是基本元素。这就是为什么有一个lea rdi，[rsp 20]来设置arg，以及为什么存储区使用[rdi]来定义没有位移的点。__attribute__（（noclone））会阻止它。

这种过程间优化非常简单，在这种情况下可以节省1字节的代码大小（在克隆的寻址模式下，只需disp8），但在其他情况下也很有用。调用者需要知道这是函数修改版本的定义，比如void foo_clone（int*p）{*p=42；} ，这就是为什么它需要将其编码为损坏的符号名称。

如果您在一个文件中实例化了模板，并从另一个看不到定义的文件中调用它，那么如果没有链接时间优化，gcc将不得不调用常规名称，并像编写的函数那样传递指向数组的指针。

IDK为什么gcc这样做是为了模板，而不是参考。这可能与它警告模板版本有关，但不是参考版本。或者可能与推导模板有关？

顺便说一句，让main使用mov-rdi，rsp而不是lea-rdi，[rsp 4]的IPO实际上会让它运行得稍微快一点。i、 e.采取

但这只对像main这样的调用者有帮助，他们已经在rsp之上分配了4个字节的数组，我认为gcc只寻找使函数本身更高效的首次公开募股，而不是在一个特定调用者中的调用序列。