Newsgroup: it.comp.lang.c
Titolo: [Ling. C]Gestire gli errori e aumentare l'heap

Ciao a tutti ho due problemi di cui non riesco a trovare la soluzione:
1. Ho scritto un programmino che alloca e dealloca dinemicamente
memoria.Quando però le informazioni da memorizzare diventano troppe il
programma si pianta. Credo sia un errore di stack overflow ma come
faccio a catturare un errore del genere in C? C'è un meccanismo simile
a java?
2. Visto che non posso diminuire la dimensione degli input c'è un modo
per chiedere al compilatore di allocare più memoria(in questo caso si
tratta dell'heap del processo principale in cui vengono memorizzati i
dati e non dello stack di sistema che serve per le chiamate di
funzioni giusto)?
Grazie mille.....

 per chiedere al compilatore di allocare pi� memoria
La memoria la allochi tu con malloc().
Al massimo puoi sbattere contro i limit dello heap (saranno in genere 1-2-3 
GB...? dipendera' anche dall'OS). Se davvero hai cosi' tanti GB di dati, 
potresti voler passare ad un SO a 64 bit (e avere abbastanza RAM, che se ti 
swappa tutto su disco e' la fine...)
Pleg 

 errore del genere in C? C'è un meccanismo simile a java?
Visto che provieni da Java ti faccio una domanda: sei sicuro di 
disallocare la memoria con free() quando non ne hai più bisogno?
-- 
"Le opinioni dei fanatici prescindono dai fatti"
python -c "print 'bG9ybWF5bmFAZ21haWwuY29t'.decode('base64')"
Linux Registered User: 461615

elemento");
return 0;}
else {
if(head==NULL){
head=tmp2;
tmp2->next=NULL;
queue=tmp2;
}
else{
tmp2->next=NULL;
queue->next=tmp2;
queue=tmp2;
}
}
}
for(i=0;i<altezzasub;i++)
{ for(j=0;j<larghezzasub;j++){
tmp2->elemento[k++]=arr[h++];
cover[h-1]=COVERED;
}
h+=LARGHEZZA-larghezzasub;
}
}
}
}
else printf("\n\nPORZIONE TROPPO PICCOLA DA ANALIZZARE\n\n");
x=1;
tmp2=head;
while(tmp2!=NULL)
{
printf("\n\nSTAMPO %d° SOTTOPORZIONE DELLA MATRICE - DIMENSIONI %d X
%d\n\n",x,tmp2->largh,tmp2->alt);
for(i=0;i<(tmp2->largh*tmp2->alt);i++)
{
printf("%5d",tmp2->elemento[i]);
}
tmp2=tmp2->next;
x++;
}
return 0;
}

 cover[h-1]=COVERED;
controlla quanto vale "h" in questa istruzione, mi pare che alla seconda 
iterazione sfori il buffer riservato a "cover".
E.

elemento");
return 0;}
else {
//SEMPLICE INSERIMENTO NELLA CODA
if(head==NULL){
head=tmp2;
tmp2->next=NULL;
queue=tmp2;
}
else{
tmp2->next=NULL;
queue->next=tmp2;
queue=tmp2;
}
}
}
//RIEMPIO L'ARRAY TMP2->ELEMENTO CREATO CON GLI OPPORTUNI ELEMENTI
DELLA MATRICE
for(i=0;i<altezzasub;i++)
{ for(j=0;j<larghezzasub;j++){
tmp2->elemento[k++]=arr[h++];
cover[h-1]=COVERED;
}
//INCREMENTO PER PASSARE ALLA "RIGA" SUCCESSIVA DELLA MTìATRICE
h+=LARGHEZZA-larghezzasub;
}
}
}
//STAMPO DEL CONTENUTO DELLA CODA


 lisco con matrici 1000x1000 si pianta....
Quasi sicuramente oltrepassi lo spazio disponibile nello stack. Nota che,
con con quelle dimensioni, le definizioni di vect, arr e cover richiedono
12MB (assumendo sizeof int = 4). Sotto Linux, la dimensione di default
dello stack � di 8172K. Se la aumento il tuo programmino gira. Sotto
Windows mi pare sia 1024K, ma potrei sbagliarmi. Soluzioni: aumentare la
dimensione dello stack, oppure (molto meglio) allocare gli array
dinamicamente.
Max

 struct lista_array *head=NULL,*queue=NULL,*tmp2;
$ lsodgf0@monica:~ > ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 3967
max locked memory       (kbytes, -l) 32
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 3967
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited
In ambiente linux, di default, vi è un limite di 8 MB nell'allocazione 
dello stack e il tuo programma ne riserva almeno 12.  Puoi provare ad 
allocare i vettori arr[], vec[][] e cover[] in modo statico dato che 
non vi sono limiti (sempre se usi il default)  al segmento dati.
Oppure si può aumentare il valore max dello stack con il comando
ulimit -s xxxxx	
impostando un valore molto più alto.
In altri ambienti non saprei ma può esistere un comando equivalente.
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   < 
http://giovanni.homelinux.net/
 >

Grazie mille ho risolto il problema allocando dinamicamente gli array
(chiamando malloc etc...).
Mi sono nate però due nuove domende:
1. Per un array l'allocazione dinamica è arr=malloc((ALTEZZA*LARGHEZZA)
*sizeof(int))
    ma come faccio per array multidimensionale?In questo caso la
matrice vect[][]?
2.Anche se non ne ho avuto bisogno e sò che è molto sconsigliata come
pratica,sotto windows come faccio per aumentare lo stack? Lo posso
fare dal sorgente come quando facendo una fork decido i parametri nel
nuovo processo(e quindi anche dello stack),o lo posso fare solo quando
lancio l'exe?
Per non rimanere nell'ignoranza...nel frattempo grazie a tutti per la
pazienza e l'aiut....mi avete dato modo anche di chiarirmi le idee
sull'utilizzo dello stack e dell'heap...