为什么会出现堆栈溢出

Question

Linux下启动

ulimit -s 1024

限制堆栈大小。

首先是一个可以运行的程序：

#include <stdio.h>

static int calc(int c,int *array)
{
    if (array!=NULL) {
        if (c<=0) {
            array[0]=1;
            return 1;
        }
        calc(c-1,array);
        array[c]=array[c-1]+3;
        return array[c];
    } else {
        int a[2500+c];
        calc(c-1,a);
        a[c]=a[c-1]+3;
        return a[c];
    }
}

int main()
{
    int result;
    result = calc(1000,NULL);
    printf("result = %d\n",result);
}

现在，如果我将 int a[2500+c]; 更改为 int a[2500];，那么程序会因堆栈溢出（分段错误）而崩溃。

我试过这个

• gcc-4.4.7 -O0, gcc-4.4.7 -O2, gcc-4.4.7 -O3
• gcc-4.8.4 -O0, gcc-4.8.4 -O2, gcc-4.8.4 -O3
• gcc-4.9.3 -O0, gcc-4.9.3 -O2, gcc-4.9.3 -O3

如果我使用

ulimit -s 1024

然后带有int a[2500]; 的版本崩溃，而带有int a[2500+c]; 的版本可以工作。

为什么使用可变长度数组 (int a[2500+c];) 的程序版本比使用固定长度数组 (int a[2500];) 的程序版本占用更少的堆栈空间？

Answer 1

正如your previous question 的cmets 中提到的，“为什么”是编译器的实现细节。该标准没有规定堆栈的布局方式（或者是否有堆栈）。正如您所见，同一个编译器的不同版本，或者具有不同优化设置的同一个版本，可以改变编译器在后台的工作方式。

话虽如此，编译器可能会为函数中任何地方声明的所有变量分配堆栈空间，这些变量在进入函数时不是 VLA。它可能以某种对开发人员不透明的方式更有效。使用 VLA，直到运行时才知道大小，因此分配方式不同。

在这种情况下，您最好使用 malloc 而不是使用本地数组。这会给你更多的确定性行为。

....
} else {
    int *a = malloc(c * sizeof(int));
    if (a == NULL) {
        perror("malloc failed");
        exit(1);
    }
    calc(c-1,a);
    a[c]=a[c-1]+3;
    int rval = a[c];
    free(a);
    return rval;
}