Newsgroup: it.comp.lang.c
Titolo: Leggere un array dinamico di strutture

Salve,
sto cercano di capire il motivo per cui questo programma non funziona:
#include <stdlib.h>
#include <stdio.h>
#define TABLE_SIZE 100
int main()
{
typedef struct nodo lettura;
struct nodo
{
char data[10];
float temperatura;
};
int i;
lettura *table;
table=(lettura *) (TABLE_SIZE*sizeof(lettura));
for(i=0;i<10;i++)
{
    printf("\nInserisci la temperatura:");
    scanf("%f",(table+i)->temperatura);
    //printf("%s\n",(table+i)->temperatura);
}
for(i=0;i<10;i++)
{
        printf("%f\n",(table+i)->temperatura);
}
return 0;
}


non sono sicuro perché stai usando costrutti che non
userei quindi si sa come vanno le cose... ma mi pare
che "table" non stia puntando ad alcuna locazione di
memoria.
-- 
Un bruco in un piatto di spaghetti:
"ahhh, finalmente un'orgia!"

 locazione di memoria.
scusami, mancava la malloc
#include <stdio.h>
#define TABLE_SIZE 100
int main()
{
typedef struct nodo lettura;
struct nodo
{
char data[10];
float temperatura;
};
int i;
lettura *table;
table=(lettura *) malloc(TABLE_SIZE*sizeof(lettura));
for(i=0;i<10;i++)
{
    printf("\nInserisci la temperatura:");
    scanf("%f",(table+i)->temperatura);


     scanf("%f",(table+i)->temperatura);
I parametri da passare allo scanf sono i *puntatori* alle locazioni di 
memoria in cui vuoi che vengano scritti i dati. Dunque manca un & dopo 
la virgola. Strano che il compilatore non te lo segnali.
E.



Se metto la & il compilatore mi segnala un errore, 
error: invalid type argument of 'unary * ' (have float)
Francesco


mmmm, in effetti... però presuppone un intervento
intelligente del compilatore se come credo la
funzione è dichiarata con numero variabile di
argomenti. Anzi, diciamo che se me lo segnalasse con
un warning lo accetterei, se me lo segnalasse come
errore inizierei a diffidare di un compilatore tanto
intraprendente...



copincollo quello che or ora ha passato MinGw e il 
Borland, senza warning. E girano entrambi correttamente.
ciao!
Apx.
#include <stdlib.h>
#include <stdio.h>
#define TABLE_SIZE 100
int main()
{
   typedef struct nodo lettura;
   struct nodo
   {
     char data[10];
     float temperatura;
   } ;
   int i;
   lettura *table;
   table=(lettura *) malloc 
(TABLE_SIZE*sizeof(lettura));
   for(i=0;i<10;i++)
   {
     printf("\nInserisci la temperatura:");
     scanf("%f",&((table+i)->temperatura));
     //printf("%s\n",(table+i)->temperatura);
   }
   for(i=0;i<10;i++)
   {
     printf("%f\n",(table+i)->temperatura);
   }
   return 0;
}
-- 




scritta così funziona, però non capisco, table è già un puntatore,e la 
funzione scanf si aspeta un puntatore, quindi, perchè aggiungere la & ?
Ps. il codice è stato compilato con gcc, con codeblocks in esecuzione 
sotto Linux
Francesco 


(table+i) è sì un puntatore, ma se accedi a un campo
del record quel che ottieni non lo è più :), ottieni 
il valore contenuto nel campo.


 intraprendente...
Penso si riferisca a gcc, che ha un comportamento
un po' piu' intelligente con alcune funzioni della famiglia
printf e scanf e verifica (se puo') la coerenza dei parametri
emettendo dei warning se non corrispondono come tipo o
come numero. Sono comunque dei warning.
Per l'OP: ricordati di attivare sempre i warning, sono
molto utili e spesso dietro un semplice warning c'e'
un errore (come in questo caso! ;)
ciao
Giacomo

 Penso si riferisca a gcc, 
Sì! Pensavo che una cosa così comoda fosse stata ripresa anche dagli 
altri compilatori... In effetti la prima volta che mi ha segnalato un 
warning di quel genere sono rimasto basito, perché il compilatore non è 
tenuto a conoscere le funzioni di libreria, e la libreria non è in 
grado, da sola, ad emettere il warning.
E.

 ottieni non lo è più :), ottieni il valore contenuto nel campo.
Ho apportato le modifiche, ed il programma funziona, ma ora c'è una cosa 
strana, il seguente programma:
#define TABLE_SIZE 100
int main()
{
typedef struct nodo lettura;
struct nodo
{
char data[10];
char city[25];
float temperaturaMin;
float temperaturaMax;
};
int i;
lettura *table;
table=(lettura *) malloc(TABLE_SIZE*sizeof(lettura));
for(i=0;i<3;i++)
{
    printf("\nInserisci la data:");
    scanf("%s",&((table+i)->data));
    printf("\nInserisci la citta':");
    scanf("%s",&((table+i)->city));
    printf("\nInserisci la temperatura minima:");
    scanf("%f",&((table+i)->temperaturaMin));
    printf("\nInserisci la temperatura massima:");
    scanf("%f",&((table+i)->temperaturaMax));
}
for(i=0;i<3;i++)
{
        printf("Data: %s Citta': %s Temperatura minima: %f  Temperatura 
massima: %f\n",(table+i)->data,(table+i)->city,(table+i)->temperaturaMin,
(table+i)->temperaturaMax);
}
return 0;
}
quando stampa la data, visualizza nella stessa stringa il contenuto del 
campo city, come se non li separasse.
Francesco

 campo city, come se non li separasse.
Hai inserito da tastiera una data di esattamente 10 caratteri, quindi
il '\0' presumibilmente e' stato scritto nel primo carattere
del campo city ed e' stato quindi sovrascritto dalla successiva
scanf. Quello che ottieni in memoria e':
data[]    city[]
012345678901234 567890
23-03-2010Roma\0
Devi riservare un carattere in piu' per tenere il '\0'
char data[11];
char city[26];
data[]      city[]
01234567890 01234 567890
23-03-2010\0Roma\0
e naturalmente usando scanf senza alcun controllo il rischio e'
che l'utente inserisca piu' di 10 quindi otterresti lo
stesso problema!
ciao
Giacomo

Il Tue, 23 Mar 2010 02:05:23 -0700, Giacomo Degli Esposti ha scritto:
In effetti un errore stupido non aver previsto un carattere per '\0'.
Grazie,
Francesco