在C中增加自动数组大小后出现编译器错误

我试图计算18456个基因的相关性度量，但将宏

GENE

或

INDEX

增加到4000到5000或更大的值后，编译器（Dev C）退出。例如，它可以很好地用于：

# define GENE 4000
# define INDEX 3000 

但不包括：

#define GENE 5000 
#define INDEX 100

输入文件是一个以空格分隔的文本文件，共有18456行57列。 代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#include <limits.h>
#define GENE 5000
#define N 57
#define INDEX 1000


int main (void) {

clock_t start, stop;
double t = 0.0;

int i, j, p, q, wp, wq;
double x;
double *S_matrix = (double *)malloc(INDEX * GENE * sizeof(double));
double sum_S, S_max;
double S[11] = {0};
double r = 0.0, xbar = 0.0, ybar = 0.0, sx = 0.0, sy = 0.0;

// read E matrix

FILE *fq;
double E[GENE][N] = {{0}};

if ((fq = fopen("E_disease.txt", "r")) == NULL ) 
{
     printf("Error\n");
     exit(EXIT_FAILURE);
}

fq = fopen("E_disease.txt","r");
printf("\n");

for (i=0;i<GENE;i++)
{
    for(j=0;j<N;j++)
    {
        fscanf(fq,"%lf",&x);
        E[i][j] = x;
    }
}


printf("\n");
fclose(fq);


// calculate correlation

assert((start = clock())!=-1);

for(p=0; p < INDEX; p++)
{
    for(q=0; q < GENE; q++)
    {
        for(i=0; i<11; i++)
        {

            /*compute xbar */
            for(j = i; j < N; j++) 
            {
                xbar += E[p][j];
            }

            xbar /= N;

            /*compute ybar*/
            for(j = i; j < N; j++) 
            {
                ybar += E[q][j];
            }

            ybar /= N;

            /* compute standard deviation of x*/
            for(j = i; j < N; j++) 
            {
                sx += (E[p][j] - xbar) * (E[p][j] - xbar);
            }

            sx = sqrt(sx);

            /* compute standard deviation of y */
            for(j = i; j < N; j++) 
            {
                sy += (E[q][j] - ybar) * (E[q][j] - ybar);
            }

            sy = sqrt(sy);

            /*compute r, the correlation coefficient between the two arrays */
            for( j = i; j < N; j++ ) 
            {
                r += (((E[p][j] - xbar)/sx) * ((E[q][j] - ybar)/sy));
            }

            r /= (N); 

            if(r>0)
            {
                S[i] = r;
            }
            else if(r<=0)
            {
                S[i] = 0;
            }

         }


         for(j=0, sum_S=0; j<11; j++)
         {  
             sum_S += S[j];
         }


         for(j=0, S_max = 0; j<11; j++)
         {
            if(S[j] > S_max)
            {
                S_max = S[j];
            }
         }

      S_matrix[p*GENE + q] = sum_S/(11*S_max);

  }

}

FILE * fs;

fs = fopen ("s_matrix.txt", "w+");

for(wp=0; wp<INDEX; ++wp)
{
    for(wq=0; wq<GENE; ++wq)
    {

        fprintf(fs, "%lf", S_matrix[wp*GENE + wq]);
        fprintf(fs, "\t");
    }

    fprintf(fs, "\n");
    printf("\n");
}

fclose(fs);

stop = clock();
t = (double) (stop-start)/CLOCKS_PER_SEC;


printf("Run time: %f\n", t);    

//print results 



//return (0);

getchar();

}

---

由于固定数组声明过大，您试图在

main（）

中保留2280000字节的堆栈空间（实际上更多）。具体而言，这一行：

double E[GENE][N] = {{0}};

等同于

double E[5000][57] = {{0}};

以每双字节8字节的速度，很可能会耗尽堆栈。改为对该数组使用动态分配。例如：

double (*E)[N] = malloc(5000*sizeof(*E));

完成后别忘了释放它

全局固定分配也将起作用（即，将其声明为

main（）

功能块外部的全局分配）

static double E[GENE][N];

int main()
{
    ... your code ...
}

---

您选择的任何方法都有潜在的优点和缺点，因此请进行相应的计划。

由于固定数组声明过大，您试图在

main（）

中保留2280000字节的堆栈空间（实际上更多）。具体来说，这一行：

double E[GENE][N] = {{0}};

等同于

double E[5000][57] = {{0}};

以每双字节8字节的速度，很可能会耗尽堆栈。请改为使用该数组的动态分配。例如：

double (*E)[N] = malloc(5000*sizeof(*E));

完成后别忘了释放它

全局固定分配也将起作用（即，将其声明为

main（）

功能块外部的全局分配）

static double E[GENE][N];

int main()
{
    ... your code ...
}

---

你选择的任何方法都有潜在的优点和缺点，所以要有相应的计划。

在尝试分配内存时失败了吗？请描述它是如何工作的。编译时失败？运行时崩溃？有错误消息吗？@abelenky这是运行时崩溃。@WhozCraig，我想我说得太早了。我正在将

S_矩阵

写入文件为1000x18456矩阵。当

E

是静态的时，它工作得很好，但在每一步中运行时间都在增加，并在第12轮中再次开始退出。在尝试分配内存时它失败了吗？描述它是如何工作的。编译时失败？运行时崩溃？有错误消息吗？@abelenky这是运行时崩溃。@WhozCraig顺便说一句，我想我说得太早了。我正在将

S_matrix

作为1000x18456矩阵写入文件中。当

E

是静态的时，它工作得很好，但每一步的运行时间都在增加，并在第12轮时再次开始退出。一般来说，分配给程序的堆和堆栈空间的限制是什么？@Kunal完全依赖于实现。没有覆盖所有平台的明确答案。因此，如果我有一个需要相当大的阵列的跨平台应用程序，动态分配是更安全的方法？@Kunal，而不是冒堆栈过度扩展的风险？是的。显然，它们的管理更繁琐。非常感谢Craig！你懂吗Kunal对我的论文进行了编辑。一般来说，分配给程序的堆和堆栈空间有什么限制？它完全依赖于实现。没有涵盖所有平台的明确答案。因此，如果我有一个需要相当大的阵列的跨平台应用程序，动态分配是更安全的方法？@Kunal冒着堆积如山的风险？是的。显然，管理它们更繁琐。非常感谢克雷格！你救了我的论文。