Question

如果n是例如1.000.000编译器停止工作。为什么？长期没有帮助。

 #include <iostream>
 #include <algorithm>
 #include <iomanip>
 #include <cmath>
 #include <fstream>

使用namespace std;

int main（） { of fout ; ifstream fin ;

  fin.open("share.in");
    fout.open("share.out");

int n;
fin>>n;
    int array1[n];
        for(int i=0; i<n; i++)
    {
        fin >> array1[i];
    }


    int suma=0, sumb=0, sumc=0, a=1, b=1, c=n-2, a1=0, b1=0, c1=0, apotelesma=1000000000, mikroterhdiafora=1000000000;

        while(c>0)
        {
                while(a1<a)
                {
                suma+=array1[a1];
                a1++;
                }
                while(b1<b)
                {
                sumb+=array1[(a1+b1)];
                b1++;
                }
                while(c1<c)
                {
                sumc+=array1[(a1+b1+c1)];
                c1++;
                }



        if(max(abs(suma-sumb),max(abs(sumb-sumc),abs(sumc-suma)))<=mikroterhdiafora)
            {
                mikroterhdiafora=min(mikroterhdiafora, max(abs(suma-sumb),max(abs(sumb-sumc),abs(sumc-suma))));
                apotelesma=min(apotelesma, max(suma,max(sumb,sumc)));
            }



                suma=0;
                sumb=0;
                sumc=0;

                a1=0;
                b1=0;
                c1=0;

                c--;
                b++;


    if(c==0)
        {
            ++a;
            b=1;
            c=n-a-1;
        }
            }


    fout<<apotelesma;


    fin.close();
    fout.close();

    return 0;
}

Answer 1

对于静态数组，1,000,000有点太多了。你应该动态创建它：

int* array1 = new int[1000000];
// Do operations on array...
delete[] array1;

此行为的原因是，当您创建静态数组（int array1[1000000]）时，编译器会将其放在堆栈上，而堆栈的容量有限，当您超出该限制时，您会发现堆栈溢出不良，从而导致你的问题。另一方面，动态内存存储在堆上，仅受硬件限制，但与堆栈不同，当不再需要时，必须记住释放它。

当我有大量输入时为什么会出错

1 个答案: