Newsgroup: it.comp.lang.c
Titolo: ancora una domandina...

Buon giorno a tutti di nuovo ......ho un' altra domandina da farvi...
Sto cercando di imparare il c e sono passato a studiare le strutture.
Ho pero' dei problemi sui puntatori a stutture.
Dunque se "ptr" e' un puntatore ad una struttura che ha come campi due
stringhe (nome e cognome), cioe' se ho capito bene altri due "puntatori" a
caratteri, posso accedere ad un campo i questo modo
*(ptr.nome)      oppure  ptr->nome    giusto ?
la prima "sintassi" (e spero di aver usato il termine giusto) mi fa pensare
che , in compilazione, ho un altra "struttura di puntatori" , ogni campo di
questa "punta" ad un campo 
della variabile struct.
Cioe' se la strutura si chiama "Notizie"
Struct notizie elemento,*ptr;
ptr=&elemento;
scrivere
*(ptr.nome)='Pietro';
e' come scrivere
ptr->nome = 'Pietro';
Se cosi' non fosse io potrei anche scrivere  *(ptr).nome o (*ptr).nome ed
in questi casi avrei un solo puntatore e non il "record" (scusate ma
conoscevo solo il Pascal..) di puntatori.
Il mio libro di c per lo meno lascia intendere questo ma poi , parlando
della aritmetica dei puntatori dice che questi , quando puntano a strutture
, si "adattano" alla lunghezza in byte dei vari campi a cui puntano per cui
un' operazione del tipo ptr++ incrementa la variabile in modo tale da farla
puntare all' ELEMENTO di struttura ( e precedentemente per "elemento"
intende il CAMPO) successivo cioe' potrei far puntare al campo cognome solo
scrivendo ptr++.
A questo punto pero' non capisco piu' niente :
se scrivo ..
struct nome *punt
non dichiaro anche un 'array "infinito" di elementi di tipo struct nome
(struct nome punt[])
 e quindi  scrivere punt++ mi fa accedere alla PROSSIMA STRUTTURA (E NON AL
PROSSIMO CAMPO) ?
Chi puo' aiutarmi a capire un po' meglio come funzionao i puntatori a
strutture...??
Grazie.
-- 
Saluti 
Antonio.
E-mail   
adel...@media.cesvitec.it
(spammatemi pure tanto questo e-mail lo do a "bau" ed "oink").

Il Piocco (A.de Lucia) (
adel...@innocent.com
) wrote:
[ snip ]
: Dunque se "ptr" e' un puntatore ad una struttura che ha come campi due
: stringhe (nome e cognome), cioe' se ho capito bene altri due "puntatori" a
: caratteri, posso accedere ad un campo i questo modo
: *(ptr.nome)      oppure  ptr->nome    giusto ?
No ;)
(*ptr).nome  oppure ptr->nome
[ snip ]
: Il mio libro di c per lo meno lascia intendere questo ma poi , parlando
: della aritmetica dei puntatori dice che questi , quando puntano a strutture
: , si "adattano" alla lunghezza in byte dei vari campi a cui puntano per cui
: un' operazione del tipo ptr++ incrementa la variabile in modo tale da farla
: puntare all' ELEMENTO di struttura ( e precedentemente per "elemento"
: intende il CAMPO) successivo cioe' potrei far puntare al campo cognome solo
: scrivendo ptr++.
Il testo e' scritto male oppure hai letto con poca attenzione...
Dal KR (si parla di un array di struct):
"...Se p e' un puntatore ad una struttura, l'aritmetica su p tiene in
 considerazione la dimensione della struttura, quindi p++ incrementa p
 di una quantita' tale da farlo puntare alla struttura successiva..."
[ snip ]
: se scrivo ..
: struct nome *punt
: non dichiaro anche un 'array "infinito" di elementi di tipo struct nome
No, dichiari solo un puntatore.
[ snip ]
: Chi puo' aiutarmi a capire un po' meglio come funzionao i puntatori a
: strutture...??
Qualsiasi testo decente sul C. Io mi sono trovato bene con il 
Kernighan-Ritchie, c'e' anche in italiano ("Linguaggio C", 
seconda edizione, della Jackson).
Ciao ciao,
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

strutture...??
Io, con grande piacere..., se vuoi contattami per posta elettronica...
Andrea, mica uno qualunque...
--------------------------------------------------
"Ho cambiato signature, si vede ?" 
--
Posted from 
itaca.ulysse.it
 [195.223.254.1]
via Mailgate.ORG Server - 
http://www.mailgate.org

Ippopapero Acquatico (andrea_...@CHITIHACHIESTONIENTEbigfoot.com) wrote:
: Un bel giorno, tutt'a un tratto Il Piocco (A.de Lucia) si mise a scrivere :
: >Dunque se "ptr" e' un puntatore ad una struttura che ha come campi due
: >stringhe (nome e cognome), cioe' 
[ snip ]
: ptr->nome equivale a (*ptr).nome e non a *(ptr.nome) che e' invece 
: equivalente a ptr->nome[0]
Per niente.
'ptr.nome' semplicemente non esiste (ptr e' il puntatore alla struttura,
non la struttura).
ptr->nome[0] e' equivalente a *(ptr->nome).
Ciao ciao


 PROSSIMO CAMPO) ?
Esatto.
EMG

ptr->nome[0] e' equivalente a *(ptr->nome).
E' vero si, e' stato un errore di distrazione.
ptr.nome in realta' non esiste.
ptr->nome[0] equivale esattamente a *(ptr->nome)


NO !!!, per la ragione che ti ho esposto.
Vedi sopra.



Sono d'accordo .....ma proprio per quello che c'e' scritto sul KR ( e che
mi hai "elencato" ....credo .... in parte) sui puntatori a struct credo
cche
struct notizie *ptr
e' uguale a
struct notizie ptr []
date le "proprieta' degli array .... non credi
difatti 
int dati []
cosi' dichiaro un array ... pero' posso riferirmi agli elementi di questo
utilizzando il puntatore "dati"..
*(dati+3) e' uguale a [dati[3]];
altrimenti perchè il KR parlerebbe di struttura "SUCCESSIVA"
se faccio ptr ++. ??
Grazie per la risposta comunque, questa mia "divagazione" e solo una
"finezza".
Saluti.
Antonio. 

 se faccio ptr ++. ??
Perché per l'aritmetica dei puntatori sommando un intero ad un puntatore
si sposta questo di una quantità di memoria pari a quella occupata dal
tipo puntato.
EMG

se faccio ptr ++. ??
se tu dichiarassi 
struct notizie ptr[5];
non potresti usare "ptr++" in quanto essa e' un'espressione di assegnazione
equivalente a "ptr = ptr + 1".
Ora, secondo il C pre-ANSI (K&R prima versione), il nome di un array e' un
puntatore costante alla locazione del suo primo elemento.
La spiegazione dell'impossibilita' di un'operazione del tipo "++ptr" o "ptr++"
e' dovuta all'impossibilita' di eseguire operazioni di assegnazione su costanti.
Nel caso invece dichiarassi
struct notizie * ptr;
potresti usare tali operazioni in quanto "ptr" e' una variabile, assoggettabile
ad operazioni di assegnazione.


 puntatore costante alla locazione del suo primo elemento.
Ti vuoi salvare in calcio d'angolo? :-)))
EMG