Newsgroup: it.comp.lang.c++
Titolo: Dimensione heap

Ciao,
sto scrivendo un programma con Microsoft VC++ 6.
Ho bisogno di caricare dei dati da un file per farci varie elaborazioni 
anche in fasi successive,per cui vorrei evitare di caricare i dati ogni 
volta che ho bisogno di rielaborarli,ma mantenerli in memoria.Ho provato a 
dichiarare 8 variabili membro di tipo array di double da 52000 posti ma ho 
ricevuto un bello Stack Overflow.
Ho letto da qualche parte che nei moderni sistemi operativi,la dimensione 
dello stack è di circa 1MB.
Quanto è grande invece l'heap? 

 Quanto è grande invece l'heap?
Dovrebbe essere limitato dalla memoria fisica + virtuale disponibile.
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg
The EMG Music page:         
http://www.emagsoftware.it/emgmusic
 

 Prova a definirle esternamente ad ogni funzione.
Non capisco..Intendi porle come variabili globali?
Inoltre,sperando di non chiedere troppo,vorrei chiederti un parere sul mio 
problema....
Io ho a disposizione un file di testo in cui sono registrati i dati letti 
ogni 10 minuti da 8 dispositivi,unitamente alla data e all'ora di lettura,il 
tutto per un anno in totale.
Vorrei consentire all'utente di tracciare un grafico con l'andamento di 
questi dati relativo a un giorno,un mese o una settimana da lui scelta,ma 
vorrei evitare di dover ogni volta accedere al file per ogni singolo 
giorno/mese/settimana scelti,preferendo leggere i dati una volta sola e 
metterli in memoria per poi poterci fare qualsiasi cosa...
Perciò ho bisogno di 6*24*366=52704 campioni massimi per ogni quantità letta 
(da cui vengono fuori quegli array del mio precedente post).
In totale,quindi,avrei bisogno di 9 array da 52704 posti (8 array double per 
i dati letti dai dispositivi e uno la data/ora,dato che uso un oggetto MFC 
di tipo COleDateTime).
Il punto è:
è una scelta buona,oppure mi consiglieresti una via diversa?
è consigliabile memorizzare i dati nello stack o nello heap? 

ricevuto un bello Stack Overflow.
Invece di:
double d [52000];
usa:
double *d = new double [52000];
e quando hai finito di usare la variabile:
delete d;

 è consigliabile memorizzare i dati nello stack o nello heap? 
Come hai gia' visto, nello stack tutti quei dati non ci stanno.
Ti consiglio di definire una struttura, come la seguente:
   struct Lettura {
     double misura[8];
     COleDateTime tempo;
   }
e di memorizzarla in un vector, come il seguente:
   std::vector<Lettura> letture;
Tale vector lo puoi mettere anche sullo stack, in quanto i dati andranno 
comunque nello heap.
Per velocizzare il popolamento del vector puoi preallocare lo spazio con:
   letture.reserve(6 * 24 * 366);
-- 
     Carlo Milanesi
 
http://digilander.libero.it/carlmila

COleDateTime* m_pDateTime;
Quando l'utente sceglie di caricare i dati faccio:
 >if(!m_pTemperature)        //Controllo che la memoria non sia stata già 
allocata
 >{
 >    m_Disp1=new double[52704];
 >    m_Disp2=new double[52704];
 >    m_Disp3=new double[52704];
 >    m_Disp4=new double[52704];
 >    m_Disp5=new double[52704];
 >    m_Disp6=new double[52704];
 >    m_Disp7=new double[52704];
 >    m_Disp8=new double[52704];
 >    m_pDateTime=new COleDateTime[52704];
 >}
A questo punto caricherò i dati,che poi l'utente potà scegliere di azzerare 
a sua discrezione.
Visto che non ho nessuna esperienza in questo tipo di applicazioni,potreste 
dirmi se un approccio del genere è sbagliato o pericoloso o (spero) giusto?

>COleDateTime* m_pDateTime;
Comunque, anche senza usare array dinamici, non vedo il motivo per non 
definire la struct Lettura { double[8] misura; COleDateTime tempo; }
Dopo di che puoi eseguire
   Lettura m_Disp;
   m_Disp = new Lettura[52704];
   // uso di m_Disp[i].misura[j] e m_Disp[i].tempo
   delete [] Lettura;
Tieni conto che questo codice e' poco sicuro, in quanto se viene 
sollevata un'eccezione o c'e' un'istruzione "return" prima di "delete", 
la memoria non viene deallocata. Per renderlo sicuro, metti delete nel 
distruttore dell'oggetto di cui m_Disp e' un membro.


 dell'oggetto di cui m_Disp e' un membro.
Beh,questa variabile sarà membro della classe del dialog dell'applicazione 
pricipale (la mia applicazione è dialog based),per cui non dovrei avere 
problemi 

 č consigliabile memorizzare i dati nello stack o nello heap?
Direi che nel tuo caso non hai altra scelta che memorizzarli nello heap.
