Newsgroup: it.comp.lang.c
Titolo: Dubbio sui puntatori

Salve a tutti,
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

 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.

 }
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?

 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.

 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

 
Esame di linguaggi?

 Esame di linguaggi?
Con chi stai parlando?


Grazie a tutti,
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

 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','

Ringrazio a tutti per l'aiuto che mi avete dato...
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