Limiti di dimensione array

Question

Ho un problema di array che voglio superare, se cambio il valore di const int "are" a 2048 il programma funziona bene ma a 8192 o anche a 4096 (solo 130.000 elementi) non funziona e si rompe. Come faccio a aggirare questo?

#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

Non è necessario mettere gli array sulla pila in main(), si può altrettanto bene li allocare staticamente prima di entrare in funzione. Questo li metterà in un'area che non è limitata dalla dimensione dello stack predefinita.

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 2

allocare la matrice in modo dinamico, in quanto ci sono spesso dei limiti della quantità di dati si può avere sullo stack (che è dove le variabili locali automatici in genere finiscono):

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

Answer 3

Si sta mettendo il struttura dati sullo stack in main, ed è piuttosto enorme. È possibile aumentare la dimensione dello stack (dipende dal sistema) oppure allocare la struttura sullo heap con new o malloc.

Answer 4

È possibile iniziare con l'assegnazione di DataStructure_* non nello stack. Ad esempio anteponendo la parola chiave static.

static DataStructure_trus va; 
static DataStructure_init in; 

Answer 5

Ciò che tutti hanno detto: stai cercando di allocare un sacco di cose in pila. A lotto.

invece, dinamicamente allocare il buffer di memoria ... utilizzando un contenitore standard per la gestione della memoria:

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