|
in questo post provo a farti qualche disegnino:
char b = 'x';
char* a;
puntatore--------->???????????????
a = &;
puntatore(contiene l'indirizzo di b)--------->b
quindi quando usi nelle espressioni a senza * tu modifichi il contenuto della variabile a, che essendo un puntatore contiene un indirizzo di memoria di b, nel momento in cui usi nelle espressioni *b tu accedi alla zona di memoria puntata, quindi puoi modificare il contenuto di b
con i puntatore a puntatore si ha una situazione così:
puntatore(contiene l'indirizzo di una variabile puntatore)---------->puntatore(contiene l'indirizzo della variabile normale)------>variabile normale
quindi quando usi il puntatore senza dereferenziarlo modifichi il puntatore al secondo puntatore, nel momento in cui lo dereferenzi col primo * ottieni la zona di memoria a cui puntava quindi un altro puntatore che conterrà l'indirizzo di memoria della variabile normale, e solo alla seconda dereferenzazione otterrai la zona di memoria della variabile dove inserire il valore consono a quel tipo di dato (un char un int o quello che è stato scelto, compresi oggetti complessi)
quindi con i puntatori a puntatore(es. char**)
es.
a = indirizzo del puntatore al puntatore
*a = indirizzo alla variabile normale
**a = valore della variabile
quindi se a è un char puoi inserire 'a' solo in **a, perchè dereferenzi fino ad arrivare al char, in *a devi mettere un puntatore alla zona in cui sta il valore in **a, e *a è nella zona di memoria a cui punta a.
mi spiego?
il discorso dell'allocazione con malloc si ha quando bisogna "preparare" dello spazio in memoria per variabili più grandi di un tipo di dato semplice, in modo da avare tutto contiguo (almeno in teoria, magari oggi i pc anche se è tutto sparso riescono ad operare, ma cmq bisogna dire prima quanti a quali celle preparare)
nel caso delle stringhe:
char* str = "ciao";
str-------->'c'
str+1------>'i'
str+2------->'a'
str+3------->'o'
qui non devi allocare tu con malloc, il compilatore farà tutto solo visto che le stringhe in "" sono viste già come char*
se invece sarà l'utente ad inserire una stringa, o allochi staticamente mettendo ad esempio 1024 caratteri (facendo un vettore char str[1024] magari, un vettore altro non è che un puntatore al suo primo elemento) o gli chiedi ad esempio quanto grande sarà a quel punto con la malloc si avrà
str------->zona pronta a ricevere un char
str+1-------->zona pronta a ricevere un char
ecc...
fino a allocare appunto nello heap la memoria che serve, prendendo la memoria libera e facendo in modo che nessunaltro programma possa accederci (almeno in teoria)
se non ce questa allocazione, il puntatore punterebbe a casaccio causando errori, perchè accederebbe a zone di memoria riservate ad altri programmi o a un indirizzo che non esiste.
Quindi, un conto è allocare lo spazio giusto(la quantità di elementi) un conto e far puntare il puntatore a qualcosa.
L'errore può essere o che il puntatore è nullo (non punta a niente o a qualcosa di sbagliato) o non c'è abbastanza memoria a lui dedicata (di cui lui è partenza diciamo).
se hai un
char a[5];
il puntatore non è nullo, e ha riservate 5 celle, se provi ad accedere alla 6 anche se il puntatore a qualcosa puntava nel momento in cui si accede alla "6 celletta oltre la prima a cui puntava" quella celletta di memoria non sarebbe una risorsa del programma e causerebbe errori.
spero di averti chiarito, cmq non ti preoccupare, prima o dopo tutti si scontrano coi puntatori.
Ultima modifica effettuata da netarrow il 30/06/2007 alle 23:29 | 
