Newsgroup: it.comp.lang.c
Titolo: Scanf e vettori

Ciao,
 
mi confermate che entrambi i codici seguenti sono esatti?
 
for(i=0;i<10;i++)
	scanf("%d",&v[i])
++++++++++++++++++++++++++++++
for(i=0;i<10;i++)
	scanf("%d",v[i])
 
passare alla scanf il nome del vettore equivale a passargli l'indirizzo 
del primo elemento, giusto?
Grazie
 
---
Questa e-mail è stata controllata per individuare virus con Avast antivirus.
https://www.avast.com/antivirus
 
 

del primo elemento, giusto?
 
Nel primo caso hai dato a scanf l'indirizzo di v[i], nel secondo caso
hai dato in pasto a scanf il valore contenuto in v[i]
 
Tornando a quallo che hai detto, e premesso di considerare 'v'
dichiarato come un array di qualcosa, anche se il loro right value e'
lo stesso, v e &v[0] sono comunque due cose diverse: la prima e' un
puntatore ad array di qualcosa, e la seconda e' un puntatore a
qualcosa. A seconda delle opzioni del compilatore, lo stesso potrebbe
lamentarsi nell'uso di uno o dell'altro.
-- 
andrea - ri mi cci, name

 del primo elemento, giusto?
 
Si,ma non e' questo il caso


Il 18/05/2016 10:45, Luca ha scritto:
 
grazie a entrambi, ho capito l'errore.
Ciao


>La 1) e' corretta la due no.
 
Se volessi fare cose contorte e dichiaro v come array di puntatori (si
spera validi) a int, sarebbe il contrario :)



 
Certamente
L'importante che tu capisca il perche la soluzione 2) non e' corretta
Comunque un compilatore decente (ad esempio il gcc) aiuta,basta 
abilitare i warnings
 

 puntatore ad array di qualcosa, 
 
Se 'v' e` un array, il nome dell'array non e` un "puntatore ad array". 
Per intenderci, scrivere:
 
int v[5]; 
 
significa dichiarare un array di 5 int. 
 
Scrivere, invece:
 
int (*v)[5];
 
significare dichiarare un puntatore ad array di 5 int.
 
Sono due cose molto diverse. 
 
Il nome di un array decade, invece, in puntatore al suo primo elemento in tre casi specifici: uso di &, uso di sizeof, e inizializzazione con literal stringa.
 

 Il nome di un array decade, invece, in puntatore al suo primo elemento in tre casi specifici: uso di &, uso di sizeof, e inizializzazione con literal stringa.
 
Errata corrige: queste sono le *eccezioni* a quando il nome di un array decade in puntatore al suo primo elemento. Sono i casi in cui *NON* decade.
 

Se 'v' e` un array, il nome dell'array non e` un "puntatore ad array". 
 
Infatti, stavo parlando del suo right value. Non del left. ;)


 Infatti, stavo parlando del suo right value. Non del left. ;)
 
?
 
Hai scritto: 
 
"premesso di considerare 'v' dichiarato come un array di qualcosa, anche se il loro right value e' lo stesso, v e &v[0] sono comunque due cose diverse: la prima e' un puntatore ad array di qualcosa"
 
Se v e` dichiarato come un array di T, v *non* e` un puntatore ad array di T.
Un array di T che decade a puntatore al primo T nell'array *NON* equivale ad un puntatore ad array di T.

>Se v e` dichiarato come un array di T, v *non* e` un puntatore ad array di T.
 
Hai perfettamente ragione, solo che continui ad insistere sul left
value, che non è l'oggetto della mia frase.
 
Provo a riscrivere la mia frase:
 
"...premesso di considerare 'v'
dichiarato come un array di qualcosa, anche se il loro right value e'
lo stesso, v e &v[0] sono comunque due cose diverse..."
 
diventa
 
"...premesso di considerare 'v'
dichiarato come un array di qualcosa, anche se il valore di v e di
&v[0] sono identici, questo valore rappresenta due cose diverse..."
 
Come hai detto, un array e un puntatore ad array sono ovviamente cose
diverse e non sono la stessa cosa, ma non parlavo delle dichiarazioni,
parlavo della semantica del valore di v e di &v[0], dove nel primo
caso è "l'indirizzo del primo elemento di un array di valori di tipo
-qualcosa-", e nel secondo caso è "l'indirizzo della cella di memoria
contenente un valore di tipo -qualcosa-.
 
Spero di avere chiarito l'equivoco. 


 -qualcosa-",
 
Veramente no. Se dichiari
 
char v[ 10 ];
 
v non è l'indirizzo del primo elemento dell'array. v *è* l'array. Che 
poi in molti casi (ad esempio quando lo passi come parametro ad una 
funzione) decade all'indirizzo del primo elemento. Ma è il valore 
passato ad essere il puntatore al primo elemento. v resta l'array.
 
EMG
 
--
EMAG Software Homepage: 
http://www.emagsoftware.it
 
The EMG Music page: 
http://www.emagsoftware.it/emgmusic
 
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
 
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg
 

 -qualcosa-"
 
Anche questo e` inesatto. Il nome v non e` necessariamente l'indirizzo 
del primo elemento di un array di T, come gia` spiegato nel mio messaggio.
 
-- 
4ndre4
"The use of COBOL cripples the mind; its teaching should, therefore, be 
regarded as a criminal offense." (E. Dijkstra)
"Ora, questo "Delta11" non è nulla di più di uno scemo del villaggio" - 
(L'Accalappiafasci)

Se non si hanno ben chiari i concetti di left-value e right-value, e'
inutile discuterne.


 inutile discuterne.
 
Andrea, i "concetti" di lhs e rhs mi sono chiarissimi. Peccato che non c'entrino un bel niente con quanto si sta dicendo. Perche` non leggi i miei messaggi e cerchi di capire dove hai sbagliato?
 
 

> Perche` non leggi i miei messaggi e cerchi di capire dove hai sbagliato?
 
Probabilmente occorre che questo sforzo sia fatto da tutti, altrimenti
tutti restano sulle loro posizioni e non si raggiunge alcuna
conclusione.
 
Provo a riscrivere in modo più semplice:
 
Dato "T v[n];", T tipo, n intero, il valore di 'v' è l'indirizzo della
cella di memoria che contiene il primo elemento di tipo T facente
parte di un array di n elementi di tipo T, mentre il valore di &v[0] è
l'indirizzo della cella di memoria che contiene un elemento di tipo T.
 
Il 'succo' del discorso che volevo fare è che usando &v[0] si perde
l'informazione circa l'esistenza stessa dell'array.


 cella di memoria che contiene il primo elemento di tipo T 
 
Ti ripeto ancora una volta che questa definizione e` inesatta. Il nome 'v' *decade* nel puntatore al suo primo elemento a meno di tre circostanze specifiche. La tua definizione e` inesatta perche` se consideri i casi &v e sizeof v, per esempio, il "valore" di v e` l'intero array.
 

 il "valore" di v e` l'intero array.
 
Probabilmente stiamo dicendo la stessa cosa ma con termini diversi.
 
Quello che dici è corretto e sacrosanto, 
per esempio in sizeof(v) quello che tu chiami "intero array" io lo
chiamo "indirizzo della
cella di memoria che contiene il primo elemento di tipo T facente
parte di un array di n elementi di tipo T"
 
In entrambi i casi l'informazione che v è un array e ha n elementi,
non viene persa e sizeof farà il suo dovere.
 
In pratica, nelle mie definizioni, io vedo il "valore di v" come una
coppia costituita dal valore "fisico" effettivo e dall'informazione di
cosa rappresenta questo valore.
 
Probabilmente l'inesattezza che hai riscontrato nelle mie definizioni
dipendeva da questa scomposizione, e il solo valore, come
correttamente hai più volte voluto farmi notare, non basta.


 parte di un array di n elementi di tipo T"
 
Ma e` sbagliato!
Prova a vedere che output ti da` un sizeof v, e prova a vedere che output ti da` un un sizeof &v[0]. 

>Prova a vedere che output ti da` un sizeof v, e prova a vedere che output ti da` un un sizeof &v[0]. 
 
&v[0] avevo detto che perdeva l'informazione di array. Quindi
sizeof(&v[0]) darà solo il size di T.
 
Cfr. "&v[0] è l'indirizzo della cella di memoria che contiene un
elemento di tipo T".
 
UN elemento.


 sizeof(&v[0]) darà solo il size di T.
 
Hai scritto: "per esempio in sizeof(v) quello che tu chiami "intero array" io lo chiamo "indirizzo della cella di memoria che contiene il primo elemento di tipo T facente parte di un array di n elementi di tipo T"
 
Non e` questione di interpretazioni: v e` l'intero array. Il sizeof di v ti da` il size dell'intero array. Non e` che quello che io chiamo "intero array" tu lo chiami "indirizzo del primo elemento". Sono due cose diverse. Perche` fai tutta questa confusione?
 
Lo so benissimo cos'e` &v[0] e stai volutamente ignorando quel che tu stesso scrivi.

>Non e` che quello che io chiamo "intero array" tu lo chiami "indirizzo del primo elemento". Sono due cose diverse. Perche` fai tutta questa confusione?
 
Quello che tu chiami "intero array" io lo chiamo "indirizzo della
cella di memoria che contiene il primo elemento di tipo T facente
parte di un array di n elementi di tipo T".
 
Notare dove iniziano e finiscono le virgolette.
 
Perché continui ad omettere parti importanti di quello che ho scritto,
per darmi torto?
 
Se sei un troll, devo ammettere che sei davvero in gamba. Per me il
discorso finisce qui.


 Notare dove iniziano e finiscono le virgolette.
 
Ma che cosa stai dicendo? Io non ometto proprio niente e non ti permettere di accusarmi di essere un troll. Tu stai cercando di forzare un'interpretazione di una cosa ERRATA che hai scritto per avere ragione a tutti i costi. E` *questo* l'atteggiamento tipico di un troll. 
 
Il nome di un array *NON* e` sinonimo di puntatore al suo primo elemento. Punto.