Newsgroup: it.comp.lang.c
Titolo: dubbi su (void) e sulla dichiarazione implicita

L'altra sera mi sono messo per divertimento a scrivere
un programma per sistemare 8 regine su una scacchiera
8x8 senza che nessuna ne attacchi un'altra (problema
classico) e ho cercato di scrivere il codice C piu'
corto possibile... sono arrivato a 158 caratteri
char n[39],q=7;void s(){char*x=n+7,*e,*d;while((*x+*(e=
x+9+q)+*(d=x+31-q)?0:(*x=*e=*d='1'+q,q--?s(),1:puts(n),
q++,*x=*e=*d=0))||x--!=n);}main(){s();return 0;}
Quando viene lanciato il programma produce l'elenco
di tutte le soluzioni al problema delle 8 regine.
Quando compilo pero' ottengo 3 warning:
  - l'uso di puts() senza prototype
  - la chiamata di s() che viene detto essere una
    funzione senza prototype (due volte... una da
    dentro s() - e' una funzione ricorsiva - e una
    nella chiamata dal main)
Il primo warning ci sta... non ho infatti incluso stdio.h...
sul secondo sono dubbioso. In C si usa void f(void) per dire
in una dichiarazione che una funzione non accetta parametri
mentre dire void f() lascia non dichiarati gli argomenti.
Quando pero' uso void f() nella *definizione* a logica mi
sarei aspettato che in seguito il fatto che f non accettasse
parametri fosse assodato... e invece pare di no (per BCC55)
Cosa dice lo standard al riguardo ?
Anche sul fatto di chiamare puts senza prototype ho qualche
dubbio... Io chiamo la funzione passando un array di caratteri
(che decade nel puntatore al primo dell'array) e la deduzione
automatica mi va bene (se non sbaglio quando si chiama una
funzione senza averne specificato la dichiarazione il
compilatore deduce che si tratti di una funzione che torna un
intero e che accetta parametri esattamente del tipo passato
(escluse le promozioni automatiche char->int, float->double)
Questa deduzione dovrebbe essere compatibile con il prototype
di puts. Il programma che ho scritto e' portabile anche senza
#include <stdio.h> ?
TIA
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 #include <stdio.h> ?
per linux:
[oscar@localhost varie]$ gcc -Wall regine.c -o regine -v
gcc version 2.95.3 19991030 (prerelease)
regine.c: In function `s':
regine.c:1: warning: implicit declaration of function `puts'
regine.c: At top level:
regine.c:1: warning: return-type defaults to `int'
poi funge. 

per linux:
...
In effetti ho fatto anche io la prova e non ottengo i warning su
s()... probabilmente si tratta di un problema del BCC55.
In ogni caso cosa faccia il singolo compilatore non e' molto
significativo... con BCC55 ad esempio avevo provato una versione
ancora piu' corta che usava main() ricorsivamente; pero' so che
chiamare main all'interno di un programma C non e' portabile.


 programma ;) )
si, ma almeno un uorning... ;) 

 chiamare main all'interno di un programma C non e' portabile.
scusate se mi intrometto nel thread, ma la cosa mi interessa.. (:
perche' richiamare la main all'interno di un programma C non e' portabile?
grazie,
adre
-- 
"Feed my head with some real thoughts / And let me think instead
Of being thought / I'll say things you won't believe
Just stand back / Just let me breathe"

perche' richiamare la main all'interno di un programma C non e' portabile?
Boh... bisogna chiederlo a quelli del comitato di
standardizzazione :)
Scherzi a parte credo che il motivo di questa limitazione
e' che in alcune implementazioni il compilatore tratta
main in modo molto speciale e che quindi ci sia la
possibilita' che quella funzione non abbia le normali
convenzioni di chiamata/ritorno.
Nei programmi normali questa non e' una limitazione...
se proprio si ha bisogno di un main ricorsivo basta
scrivere qualcosa come:
  int my_main(int argc,char *argv[])
  {
    ... uso del main ricorsivo ...
  }
  int main(int argc,char *argv[])
  {
    return my_main(argc,argv);
  }
In questo caso la funzione my_main (che e' praticamente
la stessa cosa di main() non ha nessuna limitazione).
Personalmente concordo che si tratta di una asimmetria
inutile (bastava richiedere ai compilatori di realizzare
questo giochetto internamente)...
