Dubbio sui puntatori
fasf
ho un dubbio sull'uso dei puntatori. Considero ad esempio una matrice
int MiaMatrice[2][3]={....}
MiaMatrice è un puntatore e quindi una variabile contenente un
indirizzo di memoria
MiaMatrice=&MiaMatrice[0]
Tuttavia MiaMatrice[0] è anch'esso un indirizzo di memoria, dato che
l'array è bidimensionale
MiaMatrice[0]=&MiaMatrice[0][0]
con MiaMatrice[0][0] risultante essere il primo elemento della
matrice. Non capisco perché ottengo
MiaMatrice=MiaMatrice[0]
dato che mia matrice dovrebbe essere l'indirizzo mi memoria di
MiaMatrice[0] e non il suo valore....
Grazie per l'aiuto
?manu*
> Salve a tutti,
> ho un dubbio sull'uso dei puntatori. Considero ad esempio una matrice
>
> int MiaMatrice[2][3]={....}
>
> indirizzo di memoria
> MiaMatrice=&MiaMatrice[0]
No, non � cos�. MiaMatrice rappresenta l'intera zona di memoria
contenente i 2 array di 3 interi. Prova a chiedere sizeof(MiaMatrice).
> Tuttavia MiaMatrice[0] � anch'esso un indirizzo di memoria, dato che
> l'array � bidimensionale
> MiaMatrice[0]=&MiaMatrice[0][0]
Neanche. MiaMatrice[0] � la prima riga della tua matrice.
> con MiaMatrice[0][0] risultante essere il primo elemento della
> matrice. Non capisco perch� ottengo
>
> MiaMatrice=MiaMatrice[0]
Da premesse errate ottieni conclusioni errate. In ogni caso anche se tu
considerassi i puntatori:
int MiaMatrice[2][3];
typedef int Riga[3];
int main() {
Riga *p=MiaMatrice;
int *q=MiaMatrice[0];
}
vedi che i due puntatori sono diversi, pur puntando alla stessa
locazione di memoria
E.
fasf
> No, non è così. MiaMatrice rappresenta l'intera zona di memoria
> contenente i 2 array di 3 interi. Prova a chiedere sizeof(MiaMatrice).
Ok, facendo il sizeof ottengo la dimensione in byte della matrice
MiaMatrice, tuttavia il nome della matrice (in questo caso MiaMatrice)
rappresenta la locazione di memoria del primo byte appartenente alla
matrice stessa. Nell'esempio che hai fatto
> int MiaMatrice[2][3];
> typedef int Riga[3];
>
> int main() {
> Riga *p=MiaMatrice;
> int *q=MiaMatrice[0];
>
> }
assegni come valore del puntatore p l'indirizzo di memoria MiaMatrice.
MiaMatrice e MiaMatrice[0] sono entrambi indirizzi di memoria, solo
che il primo (facendo il sizeof) fornisce la dimensione della matrice,
il secondo la dimensione del primo vettore della matrice stessa. Ma il
primo byte della matrice ha stesso identico indirizzo del primo byte
del vettore, motivo per cui MiaMatrice==MiaMatrice[0]. Ragionando
sempre in termini di puntatori:
**MiaMatrice==al primo elemento (ovvero l'elemento [0][0]) della
matrice stessa==MiaMatrice[0][0]
utilizzando l'operatore &
*MiaMatrice==&MiaMatrice[0][0]==MiaMatrice[0]
dato che tutti e tre sono indirizzi di memoria dello stesso valore,
anche se puntano a tipi di dato diversi.
Dove sbaglio?
?manu*
>> contenente i 2 array di 3 interi. Prova a chiedere sizeof(MiaMatrice).
>
> Ok, facendo il sizeof ottengo la dimensione in byte della matrice
> MiaMatrice, tuttavia il nome della matrice (in questo caso MiaMatrice)
> rappresenta la locazione di memoria del primo byte appartenente alla
> matrice stessa.
Lo rappresenta nella tua mente, ma non nella logica del linguaggio. La
matrice e il puntatore al primo elemento sono tipi diversi.
> Nell'esempio che hai fatto
>
>> int MiaMatrice[2][3];
>> typedef int Riga[3];
>>
>> int main() {
>> Riga *p=MiaMatrice;
>> int *q=MiaMatrice[0];
>>
>> }
>
> assegni come valore del puntatore p l'indirizzo di memoria MiaMatrice.
La matrice decade ad un puntatore al suo primo elemento quando fai
l'assegnamento.
> MiaMatrice e MiaMatrice[0] sono entrambi indirizzi di memoria, solo
> che il primo (facendo il sizeof) fornisce la dimensione della matrice,
> il secondo la dimensione del primo vettore della matrice stessa. Ma il
> primo byte della matrice ha stesso identico indirizzo del primo byte
> del vettore, motivo per cui MiaMatrice==MiaMatrice[0]. Ragionando
> sempre in termini di puntatori:
> **MiaMatrice==al primo elemento (ovvero l'elemento [0][0]) della
> matrice stessa==MiaMatrice[0][0]
> utilizzando l'operatore &
> *MiaMatrice==&MiaMatrice[0][0]==MiaMatrice[0]
> dato che tutti e tre sono indirizzi di memoria dello stesso valore,
> anche se puntano a tipi di dato diversi.
> Dove sbaglio?
A parte quello che ti ho detto prima (considerare una matrice come il
puntatore al primo elemento) mi pare che non sbagli.
E.
Andrea Laforgia
> Ok, facendo il sizeof ottengo la dimensione in byte della matrice
> MiaMatrice, tuttavia il nome della matrice (in questo caso MiaMatrice)
> rappresenta la locazione di memoria del primo byte appartenente alla
> matrice stessa.
No. Se MiaMatrice fosse un puntatore come dici, l'operatore sizeof
restituirebbe la dimensione del puntatore e non dell'array. Il tuo
MiaMatrice � un array e il nome di un array DECADE in puntatore al primo
elemento in tutti i casi tranne tre specifici ovvero l'uso di &
(address-of), l'inizializzazione mediante string literale e l'uso di
sizeof.
> > int MiaMatrice[2][3];
> > typedef int Riga[3];
> >
> > int main() {
> > � �Riga *p=MiaMatrice;
> > � �int *q=MiaMatrice[0];
> >
> > }
> assegni come valore del puntatore p l'indirizzo di memoria MiaMatrice.
Pi� precisamente: MiaMatrice decade in puntatore e il valore contenuto in
quel puntatore viene assegnato a p.
> MiaMatrice e MiaMatrice[0] sono entrambi indirizzi di memoria, solo
> che il primo (facendo il sizeof) fornisce la dimensione della matrice,
> il secondo la dimensione del primo vettore della matrice stessa.
Non � cos�. MiaMatrice e MiaMatrice[0] sono entrambi array, non puntatori.
--
questo articolo e` stato inviato via web dal servizio gratuito
http://www.newsland.it/news segnala gli abusi ad ab...@newsland.it
MasterControl
> fasf ha scritto:
>
>> Ok, facendo il sizeof ottengo la dimensione in byte della matrice
>> MiaMatrice, tuttavia il nome della matrice (in questo caso MiaMatrice)
>> rappresenta la locazione di memoria del primo byte appartenente alla
>> matrice stessa.
>
> No. Se MiaMatrice fosse un puntatore come dici, l'operatore sizeof
> restituirebbe la dimensione del puntatore e non dell'array. Il tuo
> MiaMatrice � un array e il nome di un array DECADE in puntatore al primo
> elemento in tutti i casi tranne tre specifici ovvero l'uso di &
> (address-of), l'inizializzazione mediante string literale e l'uso di
> sizeof.
>
>>> int MiaMatrice[2][3];
>>> typedef int Riga[3];
>>>
>>> int main() {
>>> Riga *p=MiaMatrice;
>>> int *q=MiaMatrice[0];
>>>
>>> }
>> assegni come valore del puntatore p l'indirizzo di memoria MiaMatrice.
>
> Pi� precisamente: MiaMatrice decade in puntatore e il valore contenuto in
> quel puntatore viene assegnato a p.
>
>> MiaMatrice e MiaMatrice[0] sono entrambi indirizzi di memoria, solo
>> che il primo (facendo il sizeof) fornisce la dimensione della matrice,
>> il secondo la dimensione del primo vettore della matrice stessa.
>
> Non � cos�. MiaMatrice e MiaMatrice[0] sono entrambi array, non puntatori.
>
>
Esame di linguaggi?
Andrea Laforgia
> Esame di linguaggi?
Con chi stai parlando?
fasf
non avevo per nulla il concetto di decadimento di un puntatore, mi era
totalmente ignoto (il mio libro lo descrive come scritto nel primo
post, da qui la confusione)!!Sto riuscendo a capirci qualcosa: infatti
se faccio il sizeof di un puntatore ottengo 4byte (ovvero la
dimensione della variabile indirizzo di memoria), se faccio il sizeof
MiaMatrice ottengo la dimensione di MiaMatrice...
Mi potete spiegare meglio gli altri due casi in cui l'array non
decade?
> Esame di linguaggi?
Non sono laureato in informatica...sto ristudiando il C in modo da
poterlo utilizzare in una forma meno grezza e più efficiente di
quanto non lo faccia ora
Andrea Laforgia
> Mi potete spiegare meglio gli altri due casi in cui l'array non
> decade?
Gli altri due casi sono l'uso dell'operatore & (address-of) e
l'inizializzazione mediante string literal.
Spiego:
Quando usi l'operatore & su un array di elementi di tipo T, il tipo del
puntatore restituito � "puntatore ad un array di elementi di tipo T" e non
"puntatore ad un puntatore a T". Quindi l'array rimane array, non decade.
Esempio:
#include <stdio.h>
int main()
{
int array[5];
printf("array = %pn", array); /* decade */
printf("array + 1 = %pn", array+1); /* decade */
printf("&array + 1 = %pn", &array+1); /* non decade */
return 0;
}
Il secondo caso � pi� banale. Quando hai:
char name[] = "andrea";
lo string literal "andrea" non viene interpretato come puntatore ma come
array:
char name[] = {'a','n','d','r','e','a','
fasf
Vorrei sottoporvi questo breve codice
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
int main(void) {
uint8_t MiaMatrice[3][4];
printf("&MiaMatrice= %p\t\tMiaMatrice= %p\n",&MiaMatrice,
MiaMatrice);
printf("&MiaMatrice[0]= %p\tMiaMatrice[0]= %p\n",&MiaMatrice[0],
MiaMatrice[0]);
return EXIT_SUCCESS;
}
In questo caso ottengo come risultato:
&MiaMatrice= 0xbffff7f4 MiaMatrice= 0xbffff7f4
&MiaMatrice[0]= 0xbffff7f4 MiaMatrice[0]= 0xbffff7f4
Tutte e quattro le variabili rappresentano lo stesso identico valore,
cioè un indirizzo di memoria contenente il valore 32, il quale
rappresenta l'elemento MiaMatrice[0][0]
*MiaMatrice=0xbffff7f4 *MiaMatrice[0]=32
Questo penso sia l'effetto del decadimento a puntatore del vettore,
tuttavia vorrei avere un'idea più chiara di come facciano le quattro
variabili ad avere lo stesso valore: questo viene assegnato in fase di
compilazione del programma?
Grazie