Question

在我的C代码中，我为2d数组double E[2000][2000];分配内存，但是当我运行它时会得到一个运行时错误Segmentation fault(core dumped)，当我将数组大小减少到900左右时，代码运行正常。

为什么它显示运行时错误，因为双重占用64位内存（IEEE标准）所以代码应该大约32MB，这与ram大小相比并不多。如果在C中不支持，那么我应该如何继续我必须存储的最大数据量是4000000，每个都是浮点数。

Answer 1

您是否将E声明为局部变量？如果是这样，你的堆栈内存已经用完了。

void func()
{
    double E[2000][2000]; /// definitely an overflow
}

使用动态分配：

double* E = malloc(2000 * 2000 * sizeof(double));
/// don't forget to "free(E);"  later

或者，如果您需要2D阵列，请使用Z字形：

double** E = malloc(2000 * sizeof(double*));

/* check that the memory is allocated */
if(!E)
{
    /* do something like exit(some_error_code);  to terminate your program*/
}

for(i = 0 ; i < 2000 ; i)
{
      E[i] = malloc(2000 * sizeof(double));

     /* check that the memory for this row is allocated */
     if(!E[i])
     {
        /* do something like exit(some_error_code);  to terminate your program*/
     }
}

然后重新分配有点复杂：

for(i = 0 ; i < 2000 ; i)
{
      free(E[i]);
}

free(E);

P.S。如果你想以连续的方式保留所有数据，那就有一个技巧（来自Takuya Ooura's FFT Package的代码）

double **alloc_2d(int n1, int n2)
{
    double **ii, *i;
    int j;

    /* pointers to rows */
    ii = (double **) malloc(sizeof(double *) * n1);

    /* some error checking */
    alloc_error_check(ii);

    /* one big memory block */
    i = (double *) malloc(sizeof(double) * n1 * n2);

    /* some error checking */
    alloc_error_check(i);

    ii[0] = i;
    for (j = 1; j < n1; j++) {
        ii[j] = ii[j - 1] + n2;
    }
    return ii;
}

void free_2d(double **ii)
{
    free(ii[0]);
    free(ii);
}

你刚才打电话

double** E = alloc2d(2000, 2000);

和

free_2d(E);

Answer 2

我假设您只是通过

在堆栈上分配它

double E[2000][2000];

可能超过分配给程序的堆栈大小。

尝试使用malloc（或c ++中的new）或使用选项增加程序的默认堆栈大小。为此，可以使用setrlimit（）配置gcc。

setting stack size in gcc

请记住，即使堆栈大小增加，此大小的数组也应为全局

如果一个维度的大小固定

，您还可以使用单个语句在堆上分配2D数组

double (* E)[COLUMN_SIZE];
int rows = 20; // this is dynamic and can be input from user at run time
E = malloc(rows * sizeof(*E)); // this needs to be freed latter

更详细的类似例子 allocating 2d array without loops

Answer 3

这取决于您分配数组的位置。使用堆栈空间可能会导致溢出（除非您让链接器分配一个额外的大堆栈）。

例如，这可能不起作用

int main()
{
    double E[2000][2000];   // Likely an overflow
}

但是，将数组移动到静态存储区

double E[2000][2000];

int main()
{
   // use E here
}

可能会避免这个问题。

无法分配内存

3 个答案: