Newsgroup: it.comp.lang.c
Titolo: C'E' L'ERRORE MA FUNZIONA!

Questo semplice programmino calcola la somma di n numeri, il compilatore mi
da' un errore nella dichiarazione dell array ma il prog. funziona lo stesso.
Sapete dirmi cosa posso fare per far sparire il messaggio d'errore?
Grazie
******
#include <stdio.h>
double somma(double num[], int n);
int i, n;
double num[], sum = 0;
main()
{
   printf("\n\n Di quanti numeri vuoi sapere la somma? ");
   scanf("%d",&n);
   printf("\n Scrivi i %d numeri : ",n);
   for(i = 0; i < n; ++i)
      scanf("%lf",&num[i]);
   somma(num,n);
   printf("\n La somma e' %lf",sum);
   return 0;
}
double somma(double num[], int n)
{
   for(i=0; i < n; ++i)
      sum += num[i];
   return sum;
}
*******

Il compilatore ti da' l'errore ed ha pure ragione: tu dichiari un array, ma
non allochi lo spazio in memoria!
E funziona per miracolo suppongo,perche' scrivi in memoria senza averla
riservata.
Invece che un array dichiara un puntatore e poi usa la malloc() per
riservare lo spazio di n * sizeof(long) elementi.
Davide

da' un errore nella dichiarazione dell array ma il prog. funziona lo
stesso.
Scusa, ma se ti da' un errore come fa a compilare?
Marco

 
Non l'ho provato ma dovrebbe funzionare...
P.C. Io eviterei l'uso di variabili globali, quando e' possibile,
anche se in un esempio di queste dimensioni non e' molto importante,
e' solo questione di stile.
--
 Ciao, Luca.
 Reply to 
luca....@tiscalinet.it

 Marco
L'errore e' di tipo logico, non sintattico.
dichiarare un array come double num[] e' consentito a patto che tu sappia
che
e' "equivalente" a dichiarare double *num, cioè solo un puntatore all'array.
Il fatto che funzioni, come del resto già spiegato nella risposta precedente
e'
dovuto ad una questione di fortuna.
Il problema e' tipico di uno alle prime armi con il C.....
La soluzione che devi adottare se la dimensione del vettore non la conosci
a priori e' di allocarlo dinamicamente (RICORDA DI DISALLOCARE ALLA FINE).
Se non vuoi usare allocazioni dinamiche..... dichiara un array della
dimensione max
e.g. double num[MAX_VALORI]
Ciao
Stefano

 double num[], sum = 0;
Devi specificare il numero di elementi all'interno delle parentesi
quadre. Altrimenti usa l'allocazione dinamica.
EMG

 e' "equivalente" a dichiarare double *num, cioè solo un puntatore all'array.
E' consentito da chi? Dallo standard non mi pare...
EMG


ok le virgolette le dovevo mettere da consentito.... :)
 la dichiarazione mi sembra in ogni caso lecita.
Io la uso ad es. nel seguente modo
double num[] = {1.0, 2.0, 3.0, 4.0};
il mio precedente pensiero stava a significare che double num[] e double
*num
dichiarano solo un puntatore.
Grazie per la precisazione
Stefano

 double num[] = {1.0, 2.0, 3.0, 4.0};
Ma questo caso è completamente diverso dal semplice
double num[];
Quest'ultimo (sempre se non vado errato) dovrebbe essere un errore di
sintassi mentre il primo è una normale inizializzazione di un array dove
il numero degli elementi può essere omesso in quanto il compilatore lo
ricava dal numero dei valori nell'inizializzatore.
EMG

 wrote in message
news:3885C5C4...@flashnet.it...


 E' lecito anche double num[];
Il DJGPP mi dice "array size missing" e ritengo che abbia ragione.
Qualcuno può consultare lo standard e confermare o meno se quella forma
è ammessa?
EMG

 wrote in message
3885FD0F...@flashnet.it...

Per lo standard C non so, ma anche il buon vecchio borlandC dice "size of
'num' is unknown or zero",
e si inc...za anche se dichiari double num[0], dicendo "Array must have at
least one element"
bye donCiccio

 wrote in message
news:865c81$oct$1...@nslave1.tin.it...

Ok chiedo venia, stavo confondendo una cosa ammessa nel K&C standard
ma che fortunatamente non e' piu' ammessa nell' ANSI C.
Anche oggi ho imparato qualcosa di nuovo.
Sto diventando vecchio, non dovrei fidarmi solo della mia memoria :) !!
Stefano

 ma che fortunatamente non e' piu' ammessa nell' ANSI C.
Posso sbagliare ma a me sembra che non sia mai stata ammessa.
EMG


purtroppo era ammessa! i primi compilatori che ho usato trattavano
array e puntatori alla stessa stregua..... ad esempio non era raro trovare
char **argv o char *arv[]. o char argv[][]...  in generale la usavo per
passare ad una funzione un array del quale non conoscevo la dim. f(int a[]).
Stefano

 passare ad una funzione un array del quale non conoscevo la dim. f(int a[]).
A parte il fatto che il comportamento di un particolare compilatore non
può mai essere preso a dimostrazione di ciò che un linguaggio consente o
meno, io credo che tu stia facendo una grande confusione tra
dichiarazione/definizione di un array e passaggio di array come
parametri a funzioni. Nel primo caso non è ammessa l'assenza della
dimensione altrimenti (e questo è sempre valso) come farebbe il
compilatore ad allocare l'array? Nel secondo caso, invece, è più che
normale vedere array senza dimensione in quanto, in realtà, ciò che
viene passato alla funzione è sempre e comunque il puntatore al primo
elemento dell'array e dichiarare gli argomenti come array[] invece che
*array è del tutto equivalente.
Scusa l'insistenza ma penso sia importante chiarire.
EMG

che e' "equivalente" a dichiarare double *num, cioč solo un puntatore all'array.
Dove l'hai letto ? sullo Schildt ? ;)
Non č vero. La dimensione di un array va specificata
obbligatoriamente.
Andrea Laforgia (andrea_...@XXXbigfoot.com)
------------------------------------------------
Il mio indirizzo di posta elettronica č inattivo 
per il momento.

puntatore.
E quindi non dovrebbe permettere l'uso di malloc() con num[].
Andrea Laforgia (andrea_...@XXXbigfoot.com)
------------------------------------------------
Il mio indirizzo di posta elettronica è inattivo 
per il momento.

passare ad una funzione un array del quale non conoscevo la dim. f(int a[]).
Attenzione, stai confondendo le cose. Dubito molto che un qualsiasi
compilatore potesse ammettere la forma char argv[][], visto che,
comunque, si ignora una dimensione dell'array che è invece
indispensabile. D'altro canto, in C, la __dichiarazione__ di un
parametro formale array senza la specificazione del numero di
elementi, fa sì che :
funzione( char a[] ) ;
e
funzione( char *a ) ;
siano equivalenti.
Ma questo caso e' considerato un'eccezione.
