Newsgroup: it.comp.lang.c++
Titolo: Deallocazione di stringhe

Salve a tutti.
Leggendo i post precedenti mi è sorto un dubbio che spero possiate
chiarirmi. Supponiamo di avere una stringa del tipo C:
char string[20];
oppure
char *string = new char[20];
Se per qualunque motivo, la stringa dovesse ad un certo punto del programma
ingrandirsi, cioè contenere più caratteri di quanti previsti, all'atto della
fuori uscita dell'ambito di visibilità (o rispettivamente, all'atto della
chiamata delete [] string;) avrò o non avrò un memory leak? Cioè mi verrà
deallocata una quantità pari a 20 o si adatta alla nuova dimensione?
Grazie per le eventuali risposte.
--
  Jerle Shannara
Per rispondere in mail togli NO e SPAM
homepage 
http://utenti.tripod.it/jerleshannara

 si adatta alla nuova dimensione? Grazie per le eventuali risposte.
no, si deallocano sempre 20 char, sempre che ci si arrivi "integri" :)
memory leak sarebbe il caso in qui mem allocata non viene + 
rilasciata, non buffer overflow che non causano crash (vai sempre a 
scrivere in una zona di memoria considerata "non allocata", o destinata 
ad altri usi: registri sullo stack, ad es.)

 deallocata una quantità pari a 20 o si adatta alla nuova dimensione?
Un array di 20 caratteri sara' sempre un array di 20 caratteri. Se deve
contenere piu' caratteri, e' necessario allocare un nuovo array piu' grande
(30?, 40?, 100?), copiarvi i caratteri del vecchio array, e quindi lavorare
con il nuovo piu' grande.
Es:
char old_array[20]= "Contiene 20 caratt.";
char new_array[50];
strcpy(new_array,old_array);
oppure
char *old_array = new char[20];
//...
char *new_array = new char[50];
strcpy(new_array,old_array);
delete [] old_array;
//... E quando new_array non servira' piu':
delete [] new_array;
Non c'e' pericolo di memory leak se l'array viene allocato staticamente. Con
l'allocazione dinamica invece ci si deve ricordare di chiamare 'delete[]'.
Comunque, la classe std::string evita tutti questi giochetti: si espande
automaticamente e fornisce molte altre comode funzionalita'.
Ciao
Domenico Barra

 Grazie per le eventuali risposte.
Nessun memory leak (a meno che non lo allochi con new[] e dimentichi
di deallocarlo con delete[]).
Il problema che avresti e' un altro.
Se l'array e' di 20 caratteri e tu vai a scrivere oltre tale limite,
il tuo programma non e' conforme e il comportamento non e' definito.
In pratica:
-Potrebbe non succedere nulla.
-Potrebbe andare in dump il sistema.
-Potresti avere variabili (anche in tatt'altra parte del programma)
che cambiano di valore.
-In alcuni sistemi potresti influenzare altri programmi o addirittura
il funzionamento dell'HW.
-... [whatever]
E la cosa piu' divertente e' che non succederebbe sempre la stessa
cosa e nello stesso momento. Una o piu' delle cose suddette potrebbero
avvenire in qualunque momento a partire da quello in cui tu hai
scritto oltre il limite dei dati. E:
- fino al momento in cui il programma termina
- su alcuni sistemi, fino a che non spegni il computer
- se il programma scrive dati su disco, comunica con altri programmi o
altre cose del genere: fino a che non hai chiuso tutti i programmi e
cancellato tutti i file.
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

ingrandirsi, cioè contenere più caratteri di quanti previsti
Riassumendo le altre risposte... a questo punto sei già morto ^___^
Luc.