数组大小限制

Question

我有一个我想克服的数组问题，如果我将 const int "are" 的值更改为 2048，则程序运行良好，但在 8192 甚至 4096（仅 130,000 个元素）时，它无法工作并中断。我该如何解决这个问题？

#include <iostream>
#include <fstream>
#include <windows.h>

#pragma warning (disable : 4820 4619 4668 4101)

HANDLE ghEvents;

const int arc = 2048; 
const int are = 8192;

struct DataStructure_init {

    int main_seq[are][32];
    int main_seq2[are][32];
    int main_seq3[are][32];
    int main_lim[are];

};

struct DataStructure_trus {
    int net[arc]; 
    int  r6[arc];
    int thr[arc];
};

int ftrus (unsigned char cmain[],int array_inst[],DataStructure_trus& va);
int finit (DataStructure_trus va,DataStructure_init& in);

using namespace std;

int main()
{
    unsigned char cmain[are];
    int array_inst[64]={0};
    DataStructure_trus va; 
    DataStructure_init in;
    ftrus(cmain,array_inst,va);
    finit(va,in);

    cin.get();
}



int finit (DataStructure_trus va,DataStructure_init& in)
{

    int nb=0,flag=0,lock=0;

    for(int i=0;i<are;i++){

        for(int j=0;j<24;j++){
        in.main_seq[i][j]=va.thr[(i*24)+j];
        }

    }

    return 0;
}



int ftrus (unsigned char cmain[],int array_inst[],DataStructure_trus& va)
{

    int g=0; 
    ifstream in("C:\\Dev-Cpp\\DCS\\Decom\\trus.txt", ios::binary);
    unsigned char c;
    while( in.read((char *)&c, 1) )
    {       
            cmain[g]=c;
            if(cmain[g]==' ' && cmain[g-1]=='t' && cmain[g-2]=='e' && cmain[g-3]=='n')      {array_inst[1]=g+1;}
            else if(cmain[g]==' ' && cmain[g-1]=='r' && cmain[g-2]=='h' && cmain[g-3]=='t') {array_inst[9]=g+1;array_inst[21]=g-7;}
            g++;
    }
    array_inst[29]=g-2;

    for(int i=0;i<64;i++){va.r6[i]=0;}

    for(int i=array_inst[1];i<array_inst[21];i++){
        if(cmain[i]=='1'){va.net[va.r6[1]]=1;va.r6[1]++;}
                    else {va.net[va.r6[1]]=0;va.r6[1]++;}
    }

    for(int i=array_inst[9];i<array_inst[29];i++){
        if(cmain[i]=='1'){va.thr[va.r6[9]]=1;va.r6[9]++;}
                    else {va.thr[va.r6[9]]=0;va.r6[9]++;}
    }


    return 0;
}

Answer 1

动态分配数组，因为堆栈上可以拥有的数据量通常受到限制（这是自动局部变量通常结束的地方）：

unsigned char* cmain = new unsigned char[are];

Answer 2

其他人都说：你试图在堆栈上分配很多东西。很多。

相反，通过使用标准容器进行内存管理来动态分配内存缓冲区：

std::vector<unsigned char> cmain(are);

Answer 3

您不必将数组放在 main() 中的堆栈上，您也可以在进入函数之前静态分配它们。这会将它们置于不受默认堆栈大小限制的区域。

unsigned char cmain[are];
int array_inst[64]={0};
DataStructure_trus va;
DataStructure_init in;

int main() {
   ftrus(cmain,array_inst,va);
   finit(va,in);
   cin.get();
 }  

Answer 4

您可以从分配不在堆栈中的 DataStructure_* 开始。例如，通过添加 static 关键字。

static DataStructure_trus va; 
static DataStructure_init in;

Answer 5

您将数据结构放在 main 中的堆栈上，它非常大。您可以增加堆栈大小（取决于您的系统），或者使用 new 或 malloc 分配堆上的结构。