Newsgroup: it.comp.lang.c++
Titolo: passaggio dei parametri

Scusate se insisto con queste domande banali ma ho bisogno di chiarirmi le
idee.
La mia domanda č questa:
mettiamo che io abbia una funzione
void Faiqulc(int * a,int el){
*a=8;
int o=1;
a=&o;
};
e che nel main abbia dichiarato
int c=9;
int *b=&c;
Che cosa succede quando io chiamo
Faiqulc(b,3)?
La variabile locale viene creata e inzializzata al valore 3.
Fin qui ci dovrei essere, ma il puntatore b che io passo alla funzione che
effetti ha su "int *a"
argomento della funzione.
Quando io passo Faiqulc(b,3) viene creata una variabile locale puntatore nel
mio caso int * a che ha lo
stesso indirizzo di b?
Eseguendo la funzione c diventa 8 ma l'indirizzo di b non cambia dopo aver
chiamato la funzione  perche' a e b sono due variabili distinte anche se
hanno lo stesso indirizzo?
Altra domanda:
Se io ho una funzione :
int idiota(){
int i=5;
return i;
}
int f=idiota();
f e i sono due variabili ,una globale e l'altra locale alocate in due spazi
di memoria diversi.
Ditemi per favore se č giusto.
Quando io uso l'operatore assegnamento quello che succede č che il contenuto
di i variabile locale con indirizzo
diverso da f, viene copiato nello spazio di f e l'indirizzo di f rimane lo
stesso.(quindi una copia di valori)
Diverso sarebbe se avessi usato la funzione
int * idiota2(){
static int  a=9;
int * s=&a;
return s;
}
int * p=idiota2();
In questo quello che succede č che l'indirizzo di f diventa quello di s
(quindi una copia di indirizzi)
Ciao.

Correggo l'ultima frase.
 In questo quello che succede è che l'indirizzo di p diventa quello di s


 (quindi una copia di indirizzi)
OK.
Ciao. Spero di non aver detto troppe castronerie :-)

 > La mia domanda č questa:

Questo non mi č chiaro.
Forse non mi č chiaro come viene gestito dal compilatore un puntatore, e la
sua rappresentazione a basso livello.
Io me le immagino cosi':
Ipotesi:
Supponiamo che c sia memorizzato a partire dalla cella di indirizzo 1000 e
contenga 9,
il puntatore b sia memorizzato a partire dalla locazione 3000 e contenga
1000 indirizzo di c,
il puntatore locale a sia memorizzato a partire dalla locazione 6000 e
contenga 1000 indirizzo di c.
Secondo me l'operazione a=&o cambia il contenuto della locazione 6000 (&a) ,
e quindi non c'e' modo di
cambiare int *b se non quello di modificare la funzione in  void Faiqulc(int
** a,int el).
Se io chiamo Faiqulc(&b,int el) dovrei avere int **a e int**b due variabili
distinte con &a!=&b e
*a e *b che si riferisco entrambi alla locazione 3000 e quindi facendo
*a=NULL cambio l'indirizzo
di int *b globale, e questa volta dovrei non poter modificare int **b.
Questo ragionamento contorto va bene oppure c'e' una spiegazione diversa e
piu' semplice?
Ciao.

 wrote in message
news:9Ax67.10845$NZ6.3...@news.infostrada.it...

Esatto. Era quello che intendevo. Prendiamo la funzione
void f(int *p)
{
    static int x;
    p=&x;
}
Secondo te se io poi scrivo
main(....)
{
    int *ptr;
    *ptr = 42;
    f(ptr);
}
a cosa punta ptr dopo la chiamata? all'indirizzo di x? o e' come prima?
Prova... (il bello della programmazione e' che puoi fare esperimenti di
tutti i generi senza far saltare niente per aria :-) ).
Vedila cosi': Un puntatore e' (es. architettura x86, 32 bit)
essenzialmente un numero long int. Poi c'e' il fatto che questo numero
sia visto in realta' come un indirizzo particolare nella memoria, ma a
questo pensiamo dopo.
Tu passi il puntatore a una funzione? Bene, dato che passi sempre per
valore, la funzione non puo' modificarlo, proprio perche' ne viene
creata una *copia*. Ma puo' modificare la locazione di memoria il cui
indirizzo e' contenuto nella copia, questo si'. Quindi se volessi
modificare l'indirizzo stesso di ptr? Un puntatore ad un puntatore, come
suggerivi tu.
Quindi cos'e' (a questo livello, naturalmente) un puntatore? Un
"espediente" per aggirare la faccenda del passaggio di argomenti per
valore.
Ciao.

 valore.
E i riferimenti che esistono a fare?
ciao
-- 
Luigi
--
bug windows [5] = {"95", "98", "NT", "Me", "2000"};
togli "tilescarpe" per rispondere via e-mail

 }
L'ho provato e non cambia l'indirizzo.
Cmq perň ho provato a modificare il codice mettendo int* ptr prima del main 
č da errore. Sai perchč?


 è da errore. Sai perchè?
Uh, ma mandale ad Alessio queste perplessita' :-)...  (a parte che
questa neanche l'ho capita).

 ciao
Per i l-value per esempio; un tipico uso e' negli operatori.
Ciao.

č da errore. Sai perchč?
Il codice per come e' scritto non compila comunque ... non
e' meglio verificare con un compilatore prima di fare post
di codice ?
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 di codice ?
Visto che siamo in tema di puntatori, secondo voi a cosa puo' servire 
un puntatore int *******p; 
I creatori non hanno posto dei limiti a quanto pare.....
Ciao.

 (quindi una copia di indirizzi)
Si`. In questo caso puoi passare un puntatore ad un variabile locale
perche` questa e` statica, sopravvive, cioe`, anche dopo che la funzione
e` terminata.
ciao
Kronos
PS: cerca di indentare il tuo codice, cosi` sara` piu` leggibile
-- 
Home: 
http://kronoz.cjb.net
La teoria e` quando sappiamo come funzionano le cose ma non funzionano.
La pratica e` quando le cose funzionano ma non sappiamo perche`.
Abbiamo unito la teoria e la pratica: le cose non funzionano piu` e non
sappiamo il perche`.

 distrutto e b punta ad un area di memoria non piu` valida.
Ma l'indirizzo di b non cambia dopo la chiamata di funzione, almeno da
quando mi hanno detto e da
quanto ho potuto vedere io stesso.
b punta sempre a c anche dopo Faiqulc(b,3).
Io credo sia la variabile locale int * a temporanea che punta ad un altra
variabile locale o, ma entrambe vengono
distrutte alla fine della funzione.
Cosa intendi per puntatore visibile fuori dalla funzione?
int *a non è la copia di int * b ma &a!=&b?
Ale.
Ciao.

 di codice ?
Chiedo venia :-) mi sono concentrato piu' sulla funzione che sul main...