编译器如何在编译时不知道大小的情况下分配内存？

Question

我编写了一个 C 程序，它接受来自用户的整数输入，用作整数数组的大小，并使用该值声明一个给定大小的数组，我通过检查大小来确认它数组。

代码：

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int n;
    scanf("%d",&n);
    int k[n];
    printf("%ld",sizeof(k));
    return 0;
}

令人惊讶的是它是正确的！该程序能够创建所需大小的数组。
但是所有的静态内存分配都是在编译时完成的，而在编译时n的值是未知的，那么编译器为什么能够分配所需大小的内存呢？

如果我们可以像这样分配所需的内存，那么使用malloc() 和calloc() 进行动态分配有什么用？

Answer 1

这个结构的内存，称为“可变长度数组”，VLA，以类似于alloca 的方式在堆栈上分配。这究竟是如何发生的取决于您使用的编译器，但本质上是在已知大小时计算大小，然后从堆栈指针中减去 [1] 总大小。

你确实需要malloc 和朋友，因为当你离开这个函数时，这个分配“死”了。 [而且它在标准 C++ 中无效]

[1] 对于使用“向零增长”的堆栈的典型处理器。

Answer 2

这不是“静态内存分配”。您的数组k 是一个可变长度数组 (VLA)，这意味着该数组的内存是在运行时分配的。大小将由n 的运行时值决定。

语言规范没有规定任何特定的分配机制，但在典型的实现中，您的k 通常最终会成为一个简单的int * 指针，实际内存块在运行时在堆栈上分配。

对于 VLA sizeof 运算符也在运行时进行评估，这就是您在实验中从中获得正确值的原因。只需使用%zu（不是%ld）来打印size_t 类型的值。

malloc（和其他动态内存分配函数）的主要目的是覆盖适用于本地对象的基于范围的生命周期规则。 IE。用malloc 分配的内存“永远”分配，或者直到你用free 明确地取消分配它。使用malloc 分配的内存不会在块末尾自动释放。

在您的示例中，VLA 不提供这种“破坏范围”功能。您的数组k 仍然遵守常规的基于范围的生命周期规则：它的生命周期在块的末尾结束。因此，一般情况下，VLA不可能替代malloc等动态内存分配函数。

但在特定情况下，当您不需要“击败作用域”而只需使用malloc 来分配运行时大小的数组时，VLA 确实可能被视为malloc 的替代品。请再次记住，VLA 通常是在堆栈上分配的，直到今天在堆栈上分配大块内存仍然是一种相当有问题的编程实践。

Answer 3

在 C 中，编译器支持 VLA（可变长度数组）的方式取决于编译器 - 它不必使用 malloc()，并且可以（并且经常）使用有时称为“堆栈”的东西" 记忆 - 例如使用不属于标准 C 的alloca() 等系统特定函数。如果确实使用堆栈，则数组的最大大小通常比使用malloc() 可能小得多，因为现代操作系统允许程序的配额要小得多堆栈内存。

Answer 4

可变长度数组的内存显然不能静态分配。但是，它可以在堆栈上分配。通常，这涉及使用“帧指针”来跟踪函数堆栈帧的位置，以应对堆栈指针的动态确定变化。

当我尝试编译您的程序时，似乎实际发生的情况是可变长度数组得到了优化。所以我修改了你的代码以强制编译器实际分配数组。

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int n;
    scanf("%d",&n);
    int k[n];
    printf("%s %ld",k,sizeof(k));
    return 0;
}

使用 gcc 6.3 为 arm 编译的 Godbolt（使用 arm，因为我可以读取 arm ASM）将其编译为 https://godbolt.org/g/5ZnHfa。 （我的cmets）

main:
        push    {fp, lr}      ; Save fp and lr on the stack
        add     fp, sp, #4    ; Create a "frame pointer" so we know where
                              ; our stack frame is even after applying a 
                              ; dynamic offset to the stack pointer.
        sub     sp, sp, #8    ; allocate 8 bytes on the stack (8 rather
                              ; than 4 due to ABI alignment
                              ; requirements)
        sub     r1, fp, #8    ; load r1 with a pointer to n
        ldr     r0, .L3       ; load pointer to format string for scanf
                              ; into r0
        bl      scanf         ; call scanf (arguments in r0 and r1)
        ldr     r2, [fp, #-8] ; load r2 with value of n
        ldr     r0, .L3+4     ; load pointer to format string for printf
                              ; into r0
        lsl     r2, r2, #2    ; multiply n by 4
        add     r3, r2, #10   ; add 10 to n*4 (not sure why it used 10,
                              ; 7 would seem sufficient)
        bic     r3, r3, #7    ; and clear the low bits so it is a
                              ; multiple of 8 (stack alignment again) 
        sub     sp, sp, r3    ; actually allocate the dynamic array on
                              ; the stack
        mov     r1, sp        ; store a pointer to the dynamic size array
                              ; in r1
        bl      printf        ; call printf (arguments in r0, r1 and r2)
        mov     r0, #0        ; set r0 to 0
        sub     sp, fp, #4    ; use the frame pointer to restore the
                              ; stack pointer
        pop     {fp, lr}      ; restore fp and lr
        bx      lr            ; return to the caller (return value in r0)
.L3:
        .word   .LC0
        .word   .LC1
.LC0:
        .ascii  "%d\000"
.LC1:
        .ascii  "%s %ld\000"

Answer 5

当说编译器在编译时为变量分配内存时，这意味着这些变量的位置由编译器生成的可执行代码决定并嵌入，而不是编译器在工作时为它们腾出空间。 实际的动态内存分配由生成的程序在运行时进行。