Newsgroup: it.comp.lang.c
Titolo: char* e allocazione memoria

Ciao All,
Ho, credo, capito quasi tutto dei puntatori char* (scusate ma vengo dal
[Turbo]Pascal :) ) ma mi sfugge questo: se io scrivo
main()
{
    char *pippo="Hello World";
}
viene allocata automaticamente memoria per la stringa+1(null), ma poi, quando
il programma termina, viene deallocata?
Se poi ho:
char* test(const char *parm)
{
    char *tmp;
// nota: sto studiando c++ non so se new e' solo del c++, sorry
    tmp=new char[sizeof(parm)];
    strcpy(tmp, parm);
    return tmp;
}
main()
{
    printf(test("Test"));
}
qui praticamente la memoria di tmp rimarrebbe allocata, no? Se allora devo
creare una funzione che mi ritorna una stringa senza preoccuparmi
dell'allocazione di memoria come devo fare?
A proposito, voi in genere scrivete
tipo* nomefunzione
o
tipo *nomefunzione?
Ciao,
FC - 
fc...@softhome.net
FidoWEB -> 
http://bbs.romacivica.net/fido

Ciao Francesco,
Sabato 25 Dicembre 1999 alle 23:18, Francesco Cipriani scrisse a All riguardo <
char* e allocazione memoria >:
 FC>     tmp=new char[sizeof(parm)];
scusate, questa e' tmp=new char[strlen(parm)+1], vero?
Ciao,
FC - 
fc...@softhome.net


secondo me, e' piu' leggibile:char*    NomeFunzione(...)
Ivan Molella
--
Posted from 
mta09-acc.tin.it
 [212.216.176.40]
via Mailgate.ORG Server - 
http://www.mailgate.org

 allocazione.
Mi correggo ero un po dsitratto:
tmp = malloc( sizeof(char) * sizeof(parm) ); anche se l'uso di sizeof(parm) e' impropio in
questa allocazione

 tipo *nomefunzione?
Io, normalmente, preferisco la seconda notazione.
EMG

 scusate, questa e' tmp=new char[strlen(parm)+1], vero?
Esatto.
EMG
PS. Come sospettavi, new non esiste in C ma solo in C++.


Errore:    mentre tu devi allocare memoria per una stringa di "strlen(stringa)+1" bytes.


Ciao 
e.m.gi...@flashnet.it
,
Domenica 26 Dicembre 1999 alle 12:06, 
e.m.gi...@flashnet.it
 scrisse a All
riguardo < Re: char* e allocazione memoria >:
 >> char *pippo="Hello World";
 >> viene allocata automaticamente memoria per la stringa+1(null), ma poi,
 >> quando il programma termina, viene deallocata?
 emg> Si. Il criterio, in generale, è questo: per la memoria che allochi
 emg> esplicitamente hai anche la responsabilità della relativa
 emg> deallocazione mentre della memoria che alloca il compilatore non te ne
 emg> devi preoccupare.
In effetti poi rileggendo il Lippman stasera e' venuto fuori che li' pippo e'
un puntatore a una costante, e quindi le costanti sono allocate e deallocate
dal compilatore.


Ciao 
ivanm...@tin.it
,
Domenica 26 Dicembre 1999 alle 14:36, 
ivanm...@tin.it
 scrisse a All riguardo
< Re: char* e allocazione memoria >:
 i> Mi correggo ero un po dsitratto:
 i> tmp = malloc( sizeof(char) * sizeof(parm) ); anche se l'uso di sizeof(parm)
 i> e' impropio in questa allocazione
Ma sarebbe tmp = malloc(sizeof(char)*(strlen(parm)+1)) giusto? Perche' senno
per un char* allochi la memoria per tenere un puntatore e non tutti i caratteri
se non sbaglio


Ciao 
ivanm...@tin.it
,
Domenica 26 Dicembre 1999 alle 14:13, 
ivanm...@tin.it
 scrisse a All riguardo
< Re: char* e allocazione memoria >:
 i> #include<stdio.h>#include<string.h>
 i> void    test(char *stringa)
 i> {
 i>     strcpy(stringa,"Molella");
 i> }
 i> void    main()
 i> {
 i> char stringa[20] = "Ivan";
 i> test(stringa);
 i> }
Si ma tu usi non un char* ma un char [], io ho il dubbio di come funzioni la
stessa cosa ma con allocazione dinamica


Ciao 
e.m.gi...@flashnet.it
,
Domenica 26 Dicembre 1999 alle 12:06, 
e.m.gi...@flashnet.it
 scrisse a All
riguardo < Re: char* e allocazione memoria >:
 >> Se poi ho:
 >>
 >> char* test(const char *parm)
 >> {
 >> char *tmp;
 >> // nota: sto studiando c++ non so se new e' solo del c++, sorry
 >> tmp=new char[sizeof(parm)];
 >> strcpy(tmp, parm);
 >> return tmp;
 >> }
 >>
 >> main()
 >> {
 >> printf(test("Test"));
 >> }
 >>
 >> qui praticamente la memoria di tmp rimarrebbe allocata, no?
 emg> Certo. E' infatti proprio ciņ che si vuole.
Si, ma quando il programma termina, quella memoria che fine fa?
 emg> Normalmente conviene lasciare al chiamante la responsabilitą di
 emg> allocazione e deallocazione del buffer, come puoi vedere in molte delle
 emg> funzioni di libreria che gestiscono stringhe di caratteri.
Cmq, W la classe string del C++ :)), a mio parere si diventa un po' pazzi a
usare sempre queste null terminated string. Saranno pure potenti visto che e'
tutto dinamico, ma ecco perche' poi un sacco di programmi crashano


> Si, ma quando il programma termina, quella memoria che fine fa?
In teoria il SO dovrebbe essere abbastanza furbo da capire che la memoria
chiesta dal programma va rilasciata. Non ci farei un grosso conto, però, e
perdipiù non è una buona prassi. Chi alloca memoria dovrebbe anche
preoccuparsi di rilasciarla.
--
Alessandro Monti

 tutto dinamico, ma ecco perche' poi un sacco di programmi crashano
Perfettamente d'accordo.
EMG

tipo *nomefunzione?
Io generalmente :
tipo * nomefunzione()
--
Andrea Laforgia
andrea_...@bigfoot.com

 scusate, questa e' tmp=new char[strlen(parm)+1], vero?
In C sarebbe tmp = malloc(strlen(parm) + 1); se tmp e' gia' dichiarata
di tipo char* non devi fare il cast.
 Ciao, Luca.
 Reply to 
luca....@tiscalinet.it

tutto dinamico, ma ecco perche' poi un sacco di programmi crashano
pero', se crashano, non e' mica colpa delle null-terminated ;)
--
Andrea Laforgia
andrea_...@bigfoot.com

questa allocazione
sizeof( parm ) non va bene. Bisogna usare strlen(parm)+1.
Inoltre e' inutile usare sizeof(char) visto che e' sempre uguale a 1.
--
Andrea Laforgia
andrea_...@bigfoot.com

se non sbaglio
Certo, sizeof(char) e' ridondante.
--
Andrea Laforgia
andrea_...@bigfoot.com

stessa cosa ma con allocazione dinamica
allocazione dinamica ?
Non e' detto, comunque, che scrivere :
char *stringa = "Ivan" ;
comporti un'allocazione dinamica e una deallocazione dinamica.
Credo che sia una questione dipendente dall'implementazione.
--
Andrea Laforgia
andrea_...@bigfoot.com

 Credo che sia una questione dipendente dall'implementazione.
Per parlare di allocazione dinamica l'area di memoria puntata da stringa deve poter essere liberata
con una free(stringa),ma "Ivan" non e' deallocabile in quanto non allocato precedentemente con una
malloc, ma allocato automaticamente e non "manualmente"  in fase di esecuzione,quindi sara' il s.o
ad accuparsi della deallocazione
Ivan Molella
--
Posted from 
mta04-acc.tin.it
 [212.216.176.35]


deallocazione
Con "allocazione" e "deallocazione" non mi riferisco alle operazioni
svolte dal programmatore con malloc() e free(), ma dal sistema. Che
sia il sistema o il programmatore a prendere in prestito parte della
memoria, l'operazione risultante e' comunque un'allocazione.
Quando si scrive :
char *p = "stringa" ;
non si sa a priori se "stringa" sara' conservato con i dati costanti
del programma, se il sistema allochera' memoria e se poi sara'
necessario che lo stesso deallochi la memoria occupata.
--
Andrea Laforgia
andrea_...@bigfoot.com

Andrea Laforgia wrote:

Scusa ma in che caso il sistema dovrebbe deallocare la memoria occupata da "stringa"
prima della fine dell' esecuzione del processo,supponendo che la dichiarazione (char *p
= "stringa" sia ) sia fatta nel main?

 preoccuparsi di rilasciarla.
Se poi il SO usato inizia per "w" e finisce per "indows" non bisogna
_mai_ delegare al suddetto OS la deallcazione della memoria ;-)


= "stringa" sia ) sia fatta nel main?
Quasi tutti i sistemi deallocano la memoria al termine del programma.
--
Andrea Laforgia
andrea_...@bigfoot.com

Credo che sia una questione dipendente dall'implementazione.
Infatti, mi sembra che il VC++ 4.0 includa la stringa "Ivan" nell'eseguibile
(va be', questo e' un po' ovvio), e questa dovrebbe venire caricata in
memoria al lancio del programma, e morire con esso (proprio come se fosse
del normale codice), ossia
char* f()
{
    char *nome = "Ivan";
    return nome;
}
sembra essere una funzione perfettamente funzionante (in pratica sono come
variabili globali, solo che muore il loro puntatore). O no?
Saluti,
    Mardy

preoccupazione.
Ad ogni modo e' bene farlo, perche' Windows, quanto a gestione della
memoria, e' altamente inaffidabile. :-(
Saluti,
    Mardy

 _mai_ delegare al suddetto OS la deallcazione della memoria ;-)
Neanche se comincia per D e finisce per OS, se è solo per questo.
Ma in realtà volevo porre la questione su un punto di vista un po' più
astratto. L'allocazione di memoria "persa" oggi, potrebbe diventare un
problema domani, quando magari voglio inserire la funzione in una libreria.
--
Alessandro Monti