Newsgroup: it.comp.lang.c++
Titolo: Newbie

Salvi e tutti nel newsgroup, mi sono avvicinato al C++ da poco, (un paio di 
mesi)
e sto attualmente studiando i puntatori.
sto studiando sui due tomi di Deitel & Deitel, (il primo) ma non mi torna 
una cosa.
il libro definisce un puntatore in questo modo:
//puntatore ad intero
int *p;
p = &someint;
//ora deferenziando il punt. p accedo a someint, e fin qui tutto ok..
scartabellando un pň in giro ho trovato su di un libro che parla di C++/CLI 
(.NET)
questa sintassi per i puntatori nativi ad un oggetto:
N* n  = new N;
il Deitel usa invece ( per dichiarare un puntatore ad un oggetto):
N *n;
n = &object;  come per i puntatori interi.
Per favore spiegatemi che cos' č l'operatore new, sul libro non c'č!!

Elfo ha scritto:

new N ti crea un puntatore ad un oggetto della classe N...e ti rende 
l-value di quell'oggetto...

Vuoi dire che quindi mi rende n un puntatore, posso quindi dire: n->Some 
_Method(); ?
"seimess" <a@a.a> wrote in message news:g4vude$345$1...@aioe.org...


Elfo ha scritto:

esatto

 Per favore spiegatemi che cos' è l'operatore new, sul libro non c'è!!
Mi rifiuto di crederci, è troppo importante per mancare dal Deitel... :-)
Magari nel secondo tomo?
Comunque, la differenza sta nei concetti di pila (stack) e mucchio (heap).
Quando crei un oggetto così, lo crei (allochi) sulla pila:
{
	int pippo;
	// fai qualcosa
}
e l'oggetto, dopo aver «fatto qualcosa», verrà deallocato
automaticamente quando si arriva a «}» (questo è il motivo per cui si
dovrebbe sempre stare sulla pila fin quando possibile).
Si chiama pila perché gli oggetti sono creati in sequenza (impilati) e
distrutti a partire dall'ultimo creato quando si esce dall'ambito (scope):
{
	int uno;
	int due;
}
E se non mi inganno, arrivando a «}», verrà prima deallocato «due», e
poi «uno».
Però capita che a volte vuoi che un oggetto rimanga in giro anche quando
esci dall'ambito, e allora devi allocarlo nel mucchio. Si chiama
«mucchio» perché è tipicamente un posto poco ordinato :-)
Per allocale nell'heap, dicevo, devi usare «new»:
{
	int* pippo = new int;
}
E qui ho creato una bellissima perdita di memoria: esiste un int nel
mucchio, ma alla fine dell'ambito l'unico puntatore che sapeva dov'era,
pippo, è stato distrutto (l'oggetto è nel mucchio, ma il puntatore no!).
Il programma ha detto al sistema operativo di riservargli della memoria,
ma ha perso l'informazione su dove si trova, e non può più liberarla.
Le perdite di memoria sono errori bastardissimi che sono molto difficili
da trovare, perché raramente fanno schiantare il programma di botto,
anzi spesso non lo fanno schiantare per niente... fino a quando la
memoria finisce e il computer viene paralizzato dalla peste swapponica,
apparentemente senza causa.
Quindi, quando crei un oggetto nel mucchio con new, devi sempre a un
certo punto farlo fuori con delete:
{
	int* pippo = new int;
	// fai qualcosa...
	delete pippo;
}
Un buon principio di programmazione è starsene alla larga da new e
delete finché si può, e se per questo dai puntatori in generale, perché
gli errori peggiori (nel senso di più difficili da scovare) si fanno di
solito in quest'ambito.
Ovvio che a volte sono indispensabili, e quindi devi sapere come usarli
comunque.
Ciao,
- -Federico
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with SUSE - 
http://enigmail.mozdev.org
iD8DBQFIc5RwBIpu+y7DlLcRAgqeAJ9Q9ypmbc8ruurbiEqKKIjiY/xiswCgil98
ix71gig87L0u0jG/0TE4WMA=
=wFWI
-----END PGP SIGNATURE-----

 Per favore spiegatemi che cos' è l'operatore new, sul libro non c'è!!
Escludo che un qualsiasi manuale del C++ (non dico buono, ma minimamente
decente) possa omettere la trattazione di 'new' e 'delete'. Quello che
citi, poi, mi risulta essere anche piuttosto buono. (Ma potrei sbagliarmi.)
Ci sarà sicurmente un capitolo in cui sono spiegate le modalità con cui
possono essere istanziati gli oggetti e i tre tipi di lifetime (statico,
automatico e dinamico). Sono concetti fondamentali.
Max

 Per favore spiegatemi che cos' è l'operatore new, sul libro non c'è!!
C'è...c'è (p. 421), ti riporto comunque dei miei appunti di bordo presi 
un po' dal Deitel e un po' dall'Eckel, sotto la dovuta correzione di chi 
è più preparato di me.
.......................................................................
Allocazione dinamica della memoria: gli operatori new e delete
(Rif. Pag. 421 Deitel, p.563 Eckel)
Gli operatori new e delete consentono, rispettivamente, di allocare e 
deallocare oggetti nella memoria heap ovvero consentono di allocare 
dinamicamente la memoria, per tutti i tipi di dato sia quelli 
fondamentali che quelli definiti dall'utente e quindi anche oggetti di 
classi.
Sono versioni migliorate delle omologhe malloc() e free() del C.
L'operatore new crea automaticamente un oggetto allocandone la giusta 
dimensione in memoria e, se tale allocazione va a buon fine, chiama il 
costruttore dell'oggetto  restituendo un puntatore del tipo corretto1.
Es.
int* p = new int;
viene allocato sull'heap lo spazio per contenere un int.  p è un 
puntatore all'indirizzo di questo int ovvero punta all'indirizzo 
iniziale più basso occupato dall'intero (generalmente 1 int occupa 4 byte).
Volendo è possibile anche fornire un inizializzatore per l'oggetto 
appena creato:
int* p = new int (100);
Inizializza un oggetto int appena creato è gli assegna il valore 100.
Per liberare lo spazio allocato in memoria heap, si usa l'operatore delete:
delete p;
Dealloca lo spazio in memoria, ma invoca preventivamente il distruttore 
dell'oggetto di cui si richiede l'eliminazione.
ALLOCAZIONE E DEALLOCAZIONE DI UN VETTORE
Supponiamo di creare un vettore di 100 interi. La sintassi sarà la seguente:
int* p = new int [100]
p è il puntatore al primo elemento dell'array ovvero all'indirizzo 
iniziale (il più basso) dell'intero vettore.
Attenzione: per deallocare il vettore non è sufficiente invocare:
delete p;
come si fa con le variabili scalari. Questa istruzione è corretta, ma il 
suo effetto è quello di rilasciare solo la memoria occupata dal primo 
elemento;  i restanti 99 elementi rimarranno intatti in memoria.
Per cancellare dalla memoria tutti i 100 elementi, la chiamata di delete 
dovrà allora assumere la seguente sintassi:
delete [] p;

Ok Grazie seimess
"seimess" <a@a.a> wrote in message news:g501sr$h8j$1...@aioe.org...


 Comunque, la differenza sta nei concetti di pila (stack) e mucchio (heap).
E' la prima volta che sento usare queste traduzioni, ma devo dire che
per quello che certi programmatori fanno coi puntatori calza a
pennello l'espressione "mucchio selvaggio" ;-)
Ciao,
Nicola

"pila" e "mucchio" ??? stupendo!!!!!!!!!!!!
... comunque, la deallocazione della memoria nella "pila",(e relativi 
oggetti)
e posto che è implementation dependend,  in generere nei processori moderni
viene fatta *tutta* in un colpo solo.... tipicamente aggiungendo o 
sottraendo dallo
stack pointer (o puntatore alla pila) la quantità di memoria allocata 
.... non puoi
assumere che la de-allocazione di elementi automatici segua un ordine 
preciso...
bye
brix

 Comunque, la differenza sta nei concetti di pila (stack) e mucchio (heap).
[cut]
Ottima spiegazione!
Ottima anche per me che certi concetti e certe problematiche le 
conoscevo già, ma rinfrescarsi la memoria fa sempre un gran bene...
:-)
Ciao,
Giulio
-- 
OnAir:
http://www.giuliopetrucci.it
http://www.fujikomonamour.com