Newsgroup: it.comp.lang.c++
Titolo: Puntatori e parametri riferimento...

Ciao, mi sto avvicinando al c++ e leggendo un po' qua e un po' la ho
scoperto che i puntatori e i parametri riferimento sono la punta di
diamante del c, ma anche se + o - ho capito come funzionano non ho
capito la loro effetiva utilità.
Perchè fare riferimento a puntatori quando si può più semplicemente fare
riferimento ai nomi delle variabili???
Quando incremento un puntatore perchè mi incrementa la variabile e non
la locazione di memoria???
E' possibile aumentare la locazione di memoria???
Grazie a tutti!! CiozZ!!

 E' possibile aumentare la locazione di memoria???
se tu definisci una variabile:
int* pippo;
l'istruzione
pippo++;
incrementa l'indirizzo (puntatore) alla zona di memoria allocata. Tra
l'altro in questo caso non è una bella cosa farlo, in quanto il nuovo valore
del puntatore punterebbe ad una zona di memoria il cui valore e' indefinito.
l'istruzione
*pippo++
invece incrementa di 1 il valore della cella di memoria a cui punta pippo.
ciao.

 invece incrementa di 1 il valore della cella di memoria a cui punta pippo.
Ahime` no, poiche` sintatticamente la priorita` dell'operatore ++ e`
maggiore di quella dell'operatore *: l'espressione che hai scritto
incrementa pippo, e ritorna "il valore della cella di memoria" cui
pippo puntava _prima_ di venire incrementato.
++*pippo        // caso A
e
(*pippo)++      // caso B
eseguono, invece, il compito che descrivi (e tornano, rispettivamente,
come proprio valore, quello della variabile teste` incrementata cosi`
come si presenta subito _DOPO_ l'incremento [caso A], ovvero cosi`
come si presentava subito _PRIMA_ di esso [caso B]).
Alex

maggiore di quella dell'operatore *: 
Credo che quel "sintatticamente" possa confondere.
E' giusto, ma sarebbe meglio dire che ++ e * hanno la stessa
priorita', cambia solo la loro associativita'.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
---------------------------------------------

 priorita', cambia solo la loro associativita'.
Mah, differenze di opinioni su questo punto di euristica, secondo me
si rischia piu` confusione a introdurre il concetto di associativita` a
chi apparentemente sta appena appena muovendo i primissimi passi,
mentre quello di priorita` si puo` sperare gli sia gia` familiare da
altri ambiti.  Tirare una distinzione fra le due cose e` piu` rigoroso,
certo, ma secondo me rischia di apparire piu` complicato.
L'uso di "sintatticamente" e` un tentativo di distinguere, appunto,
fra priorita` in senso sintattico e _ordine_ in cui le operazioni
vengono eseguite, che e` un'altra cosa (nella mia esperienza, con
gli operatori ++ e -- postfissi e prefissi, la confusione su questo
punto e` frequentissima).
Alex

capito la loro effetiva utilità.
L'uso dei puntatori e` importante per evitare il passaggio per valori
di grosse strutture dati (sarebbe troppo costoso). Sono inoltre
utili per la realizzazione di strutture dati dinamiche e per i
programmi che devono manipolare quantita` di dati non note a
priori. I riferimenti furono introdotti nel C++ per consentire
l'overloading degli operatori, la loro introduzione ha poi
ridotto progressivamente l'importanza dei puntatori in C++.
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

 riferimento ai nomi delle variabili???
I nomi delle variabili sono costanti a compile-time, esistono _solo_ a
compile-time, e sono visibili solo dal codice che si trova all'interno di
una ben precisa regione lessicale del programma ("scope" della
variabile, o, se si vuole, del _nome_ della variabile).
Di conseguenza, c'e` una grande varieta` di compiti di programmazione
che si possono svolgere con l'uso dei puntatori, ma non "facendo
semplicemente riferimento ai nomi delle variabili".
Visto che parli di "parametri riferimento", notiamo subito che, in C++,
questi si possono spesso usare per compiti in cui, nel precedente
linguaggio C, si dovevano invece usare i puntatori.  Ad esempio,
appunto, per passare un dato _per riferimento_ ad una funzione
(cosi` che essa possa eventualmente modificarlo, ovvero anche solo
per risparmiare tempo di esecuzione, passando un indirizzo di pochi
byte invece di dovere copiare una struttura magari grossa).
Ma i riferimenti ("reference") hanno limiti ben precisi:
A    -- non possono essere nulli (i puntatori si`);
B    -- non possono cambiare valore (indicare diverse "celle di
        memoria") nell'ambito di un singolo lifetime (i puntatori
        invece si`);
C    -- non possono essere soggetti ad "aritmetica degli
        indirizzi" (i puntatori invece si`).
I riferimenti vanno dunque usati tutte _e sole_ le volte che
questi limiti sono appropriati.  Quando non lo sono, occorre
invece usare i puntatori.
Esempio del caso A: un puntatore nullo si puo` spesso
fruttuosamente utilizzare per indicare un caso speciale
("fine", "non applicabile", "non ancora calcolato", eccetera).
Esempio del caso B: spesso devo fare una serie di operazioni
su _una in particolare_ di parecchie variabili.  Grazie all'uso
dei puntatori posso determinare _una volta per tutte_ quale
sia la variabile che mi interessa, settare ad essa un puntatore,
e poi lavorare tranquillamente sul puntatore.
Il caso C e` forse il piu` importante (anche se ovviamente
si tratta di un "sottocaso particolare" del B, visto che la
modifica di un puntatore attraverso aritmetica di indirizzi
e`, appunto, un caso particolare di modifica di esso...).
Il comune idioma C++ (e C) per scandire sequenzialmente
un array (o, in C++, un std::vector) usa ad esempio i
puntatori:
    int sommali(const int* inizio, const int* fine) {
        int result = 0;
        while(inizio!=fine)
            result += *inizio++;
        return result;
    }
Alex

certo, ma secondo me rischia di apparire piu` complicato.
Be', a mio avviso e' sempre meglio partire dalle definizioni
"rigorose". D'altronde il concetto di "associativita'" dovrebbe essere
ben spiegato su ogni testo di introduzione al linguaggio.
