Newsgroup: it.comp.lang.c
Titolo: Scanf non funziona su un vettore.

Ciao a tutti.
In questo semplicissimo programma, la scanf non ha alcun effetto.
Qualcuno sa spiegarmi perchè?
Certamente è una cosa stupida, ma non riesco proprio a venirne a capo.
Grazie mille a tutti
Bizio.
***
#include <stdio.h>
#define N 5
int main(void)
{
 double poli[N] = {1, 2, 3, 4, 5};
 int i;
 printf("INserisci gli elementi del vettore: ");
 for (i = 0; i <  N; ++i)
  scanf("%f", &poli[i]);
for (i = 0; i < N; ++i)
 printf("%g", poli[i]);
 return 0;
 }
 

  
Ciao
-- 
Cybertoldo
Per rispondermi via email, sostituisci moc.liamg con 
gmail.com

 Qualcuno sa spiegarmi perchè? 
Mi pare un classico caso di PBCAK.

 (le costanti double sopra dovresti scriverle: 1.0, 2.0, 3.0, 4.0, 5.0)
Non c'è nessun problema con quelle costanti.  Perché "dovrebbe" ?
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 Non c'è nessun problema con quelle costanti.  Perché "dovrebbe" ?
ok, ti rigiro la domanda: perche' dovrebbe scriverle come costanti di 
tipo int?
Ciao :)


 tipo int?
A.L. non ha detto che uno /dovrebbe/ scriverle come int, ha solo
detto che non c'e' nessuna ragione che /suggerisca/ di scriverle
come 1.0, 2.0, etc.
Io le scriverei senza il punto decimale
perche' sono piu' leggibili e inoltre
risparmio di digitare 10 caratteri...
g.

 tipo int?
E io te la rigiro, perché non mi stai rispondendo: "perché DOVREBBE
scriverle come 1.0, 2.0, 3.0 ?"
Non c'è nessuna ragione precisa per farlo (1, 2, 3 vanno benissimo).


 Non c'è nessuna ragione precisa per farlo (1, 2, 3 vanno benissimo).
Alcuni motivi potrebbero essere:
- enfatizza il fatto che sono costanti floating point (non intere), chi
legge il codice lo vede "meglio"
- ci si abitua a scrivere sempre le costanti floating point con il punto
decimale anche quando la parte decimale è nulla (in altri casi non fare
questo può causare un errore)

 decimale anche quando la parte decimale č nulla 
Non serve e sopratutto non si "dovrebbe" farlo.


 Non c'è nessuna ragione precisa per farlo (1, 2, 3 vanno benissimo).
Mi chiedi se e' un errore? No. Era un mio commento, messo tra parentesi, 
e con un verbo al condizionale.
Pero', fai bene attenzione che non e' neanche un errore scrivere:
	double d = 3/2;
...ovvero, significa che, chi ha scritto il codice, voleva ottenere il 
valore 1.0 - e non 1.5 - nella variabile 'd' (perfettamente lecito).
Ma se cosi' non fosse (cioe' si voleva ottenere 1.5) probabilmente 
l'autore del codice non era abituato a scrivere sempre le costanti dei 
tipi giusti.
L'OP immagino che sia uno studente. Io gli ho consigliato la *buona 
pratica* di rendere sempre espliciti i tipi delle costanti assegnati ad 
una variabile (e di non lasciare al compilatore il compito di 
interpretarli secondo il contesto).
Ciao
Note: qui semplifico, perche' ininfluente in questo tema di conversione 
int/double, ma per essere piu' esatti vedi c99: la tabella in 6.4.4.1


 e inoltre risparmio di digitare 10 caratteri...
questa mi sembra l'unica ragione. Ma puoi sempre ottimizzare un po' 
scrivendo:
	double poli[N] = {1., 2., 3., 4., 5.};


 Non serve e sopratutto non si "dovrebbe" farlo.
Invece e' buona pratica. Ma, Andrea, nel tuo codice fai quello che 
vuoi... :)
PS: "non si dovrebbe farlo"? ...addirittura? :)
Ciao


 Non serve e sopratutto non si "dovrebbe" farlo.
Anche qui Cybertoldo mi ha preceduto.
Esempio Cybertoldo :
double d = 3/2;
Altro esempio.
double risultato;
int operando;
operando = ...;
risultato = operando / 2.0;
Se si scrive
risultato = operando / 2;
si può avere un errore.
In questo caso serve mettere il punto decimale e lo si deve usare.
Quindi a mio avviso se ci si abitua a mettere sempre le costanti floating
point con il punto anche quando la parte decimale è nulla si evitano errori
di questo tipo (e mi pare che proprio di recente in un questo ng ci sia
stato un esempio di errore di questo tipo).

 PS: "non si dovrebbe farlo"? ...addirittura? :)
Certo, se con "non si dovrebbe farlo" si intende il contrario del tuo "si
dovrebbe farlo", ovvero se dici che è consigliabile farlo, io dico che NON
è consigliabile farlo, ma non necessariamente nel senso di "è
sconsigliabile farlo".  Se un numero non è negativo, non è necessariamente
positivo.


 variabili di tipo intero.
Problema tuo: io guardo i tipi e non mi fermo al colpo d'occhio.
Il codice non è un quadro, ma qualcosa da analizzare attentamente.


 pratica* 
Ci risiamo: non è *AFFATTO* una buona pratica, è solo il tuo modo di
vedere le cose.  Smettila di confondere le idee a chi sta imparando.


 - 1 è una costante intera di tipo int
No, a prescindere dal contesto, non puoi dirlo.
Siccome Cybertoldo ti ha preceduto, leggi la mia risposta a lui.


 Il codice non è un quadro, ma qualcosa da analizzare attentamente.
giusto :)
Ciao


 vedere le cose.  Smettila di confondere le idee a chi sta imparando.
Ma per favore...! Io confonderei le idee chiarendo quali siano i tipi 
giusti delle costanti da assegnare ad una variabile in C? Ma ti rendi 
conto di quello che stai affermando...?
Ciao


 PS: "non si dovrebbe farlo"? ...addirittura? :)
Gli estremismi dei supporter dello standard ;-)
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   Registered Linux user #337974  < 
http://giovanni.homelinux.net/
 >

 vedere le cose.  Smettila di confondere le idee a chi sta imparando.
LOL  ma chi e` che sta ingarbugliando le cose?


 tipo.
(capitolo 6.4.4.2 del C99 - Floating constants - oppure vedi [1])
La domanda qui e': puo' essere il numero 1 (scritto cosi') una "floating 
constant"?
Una floating-constant ha questa sintassi:
*) floating-constant:
	(A) decimal-floating-constant
	(B) hexadecimal-floating-constant
...lasciamo perdere (B) - non e' sicuramente il nostro caso - e vediamo 
come e' definito (A):
*) decimal-floating-constant:
	(C) fractional-constant exponent-part(opt) floating-suffix(opt)
	(D) digit-sequence exponent-part floating-suffix(opt)
Per (D) il numero '1' non puo' essere una /floating constant/ (ie. non 
ha la parte esponenziale), quindi vediamo se puo' esserlo per (C)...
L'unica componente non opzionale di (C) e':
*) fractional-constant:
	(E) digit-sequence(opt) '.' digit-sequence
	(F) digit-sequence '.'
...che, sostanzialmente ci dice che l'1 (il nostro caso d'esempio) per 
questa regola deve essere scritto come:
	1.0 oppure 1.
(fosse stato uno '0' si poteva usare anche la notazione: .0)
In conclusione, il numero "1" non puo' essere definito come una 
/floating-constant/: non e' presente ne' il punto, ne' una notazione 
esponenziale, ne' altro (vd. tutte le regole) che possano identificarlo 
come tale.
Se poi mi affermi che: "1 non è una costante intera", allora confronta 
C99 6.4.4.1 - Integer constants.
Ciao
Note:
[1] 6.4.4.2 Floating constants
Syntax
floating-constant:
	decimal-floating-constant
	hexadecimal-floating-constant
decimal-floating-constant:
	fractional-constant exponent-part(opt) floating-suffix(opt)
	digit-sequence exponent-part floating-suffix(opt)
hexadecimal-floating-constant:
	hexadecimal-prefix hexadecimal-fractional-constant
	binary-exponent-part floating-suffix(opt)
	hexadecimal-prefix hexadecimal-digit-sequence
	binary-exponent-part floating-suffix(opt)
fractional-constant:
	digit-sequence(opt) '.' digit-sequence
	digit-sequence '.'
exponent-part:
	'e' sign(opt) digit-sequence
	'E' sign(opt) digit-sequence
sign: one of
	'+' '-'
digit-sequence:
	digit
	digit-sequence digit
hexadecimal-fractional-constant:
	hexadecimal-digit-sequence(opt) '.'
	hexadecimal-digit-sequence
	hexadecimal-digit-sequence '.'
binary-exponent-part:
	p sign(opt) digit-sequence
	P sign(opt) digit-sequence
hexadecimal-digit-sequence:
	hexadecimal-digit
	hexadecimal-digit-sequence hexadecimal-digit
floating-suffix: one of
	'f' 'l' 'F' 'L'
