Newsgroup: it.comp.lang.c
Titolo: dichiarazione di main()

In un programma scritto a "regola d'arte" la "funzione" main() deve
restituire sempre un valore, in teoria, giusto?
Ma va dichiarata esplicitamente come int o si può tralasciare?

 Ma va dichiarata esplicitamente come int o si può tralasciare?
beh se la dichiarazione la fai sempre così è cosa buona :)
int main(void)
{
	...
 
	return 0;
}
Ciao Max
--
Secondo alcuni autorevoli testi di tecnica Aeronautica,
il calabrone non può volare, a causa della forma e del
peso del proprio corpo in rapporto alla superficie alare. 
Ma il calabrone non lo sa e perciò continua a volare.
                   Igor Sikorsky


Non so le "regole d'arte".
Comunque direi che va dichiarato
come
int main()
  oppure come
int main(int argc, char *argv[])
se lo dichiari solo come main()
viene assunto come int, ma il compilatore
potrebbe darti un warning.
Ricorda poi di restituirlo, il valore.
return 0; (di solito...)
ciao,
g.

 Ma va dichiarata esplicitamente come int o si puň tralasciare?
int main(void)
int main(int argc...)
č obbligatoria nel linguaggio C la restituzione di un valore.
Con il C++ e possibile usare
void main()
void main(int argc...)
int main(void)
non piů obbligatoria la restituzione di un valore. 

 void main(int argc...)
No. In C++ main() restituisce 'int'. E' possibile omettere l'istruzione
'return' (nel qual caso, sarà come mettere 'return 0'), ma la signature di
main() non può avere 'void'.
Max


prova a compilare un prog con Borland 3.1 per dos
con
void main()
{
} 

 non piů obbligatoria la restituzione di un valore. 
No. Forse in qualche implementazione del vecchio C++ (o C con classi)
era cosě. O in certi "strani" compilatori su "certi" sistemi ;-)
Lo standard ora vuole
int main() {}
oppure 
int main(int argc, char* argv[]) {}
main *deve* restituire int, come in C (Stroustrup)
Se il programma termina normalmente restituisce 0, che č un int
Stroustrup su 
http://www.research.att.com/~bs/bs_faq2.html
dice esattamente:
---
        void main() { /* ... */ }
 is not and never has been C++, nor has it even been C. See the ISO C++
standard 3.6.1[2] or the ISO C standard 5.1.2.2.1. A conforming
implementation accepts
        int main() { /* ... */ }
 and
        int main(int argc, char* argv[]) { /* ... */ }
---
void main *non č mai stato C++ e neppure C...
ciao :)
salvo  

 
Prova a compilarlo con qualcosa di più aderente allo Standard.
Max

 non più obbligatoria la restituzione di un valore. 
A me sembra un po' "strano" quello che hai scritto, dato che - da quello 
che so del C++ [conosco il linguaggio e lo uso, ma non sono un esperto, 
comunque] - le signature di una funzione o metodo non possono essere 
distinte l'una dall'altra in base al valore di ritorno.
Quindi, il compilatore dovrebbe segnalare un "conflitto" tra la prima 
forma che hai dato:
void main()
e l'ultima:
int main()
dato che differiscono per il solo valore di ritorno.
Pero', ripeto, siccome non sono un esperto di C++, puo' darsi che mi 
manchi qualche concetto a riguardo: cosa sfugge??
Grazie
Ciao,
Dan

 main() non può avere 'void'.
...infatti, altrimenti come farebbe il compilatore a "disambiguare" tra 
int main() e void main() ??

Max M. wrote:

Ok d'accordo!
Lo sò anche io che le funzioni in quanto tali devono restituire 
sempre un valore...il cui tipo se non specificato è un *int*
Ho provato con gcc 3.3 e mi da un warning perchè main non restituisce
un intero [ho usato void main(void)], ma il sorgente lo ha compilato
e lo esegue normalmente!

 Ma va dichiarata esplicitamente come int o si può tralasciare?
Compilatori "intelligenti" potrebbero lasciartela passare, ma per la
chiarezza dei sorgenti "better explicit than implicit".
E ho scritto "potrebbero" non per niente.
Ciao,
 Emmanuele.
-- 
Emmanuele Bassi (Zefram)                 [ 
http://www.emmanuelebassi.net
 ]
GnuPG Key fingerprint = 4DD0 C90D 4070 F071 5738  08BD 8ECC DB8F A432 0FF4

 }
Meglio ancora:
#include <stdlib.h>
int main (void)
{
	...
	return EXIT_SUCCESS;


 distinte l'una dall'altra in base al valore di ritorno.
Infatti e` accettata solo la forma int main(void) (o quella con argc,
argv). E` vero che non e` necessario esplicitare la return (ma solo in
main, che comunque e` una funzione particolare).
Il fatto che vecchi compilatori accettino anche void main(void) e`
irrilevante. Il fatto che il gcc recente lo accetti e` altrettanto
irrilevante, basta conoscere l'ABI ELF per capire cosa accade veramente. 
Luca
-- 
Home: 
http://kronoz.cjb.net
I went to God just to see
And I was looking at me
Saw heaven and hell were lies
When I'm God everyone dies

 e lo esegue normalmente!
Solo se lo compili come sorgente C (con gcc). Si parlava di C++.
Max


il gcc compila anche il c++, basta che il file da compilare ha estensione 
*cpp*
cosa che ho fatto!

 int main() e void main() ??
main è una funzione speciale...come tale ne è presente una sola in ogni 
programma,
quindi non deve distinguere nulla il compilatore.
Nel caso di funzioni normali, allora il tuo discorso va bene.
:-) 


 sh-2.05b$ cat temp.cpp
 void main(void)
 {
 }
 sh-2.05b$ gcc-3.3 temp.cpp
 temp.cpp:3: error: `main' must return `int'
 sh-2.05b$ ls a.out
 ls: a.out: No such file or directory
 sh-2.05b$ g++-3.3 -v
 Reading specs from /usr/lib/gcc-lib/i486-linux/3.3.3/specs
 [...]
 gcc version 3.3.3 (Debian 20040401)
(F/u su it.comp.lang.c++.)
Max

 Ma va dichiarata esplicitamente come int o si può tralasciare?
main() va *sempre* dichiarata con un valore di ritorno "int", ma non è
indispensabile che vi sia una return.
Il valore di ritorno "void" è possibile solo per quei compilatori che non
aderiscono allo standard e il codice compilato, benché possa girare
correttamente su certe piattaforme, non è portabile.
Suggerisco di non fidarsi mai di quello che dice un compilatore specifico:
il fatto che un certo compilatore compili correttamente non vuol
necessariamente dire che il codice sia conforme allo standard del
linguaggio.
Per maggiori informazioni consulta le faq del gruppo comp.lang.c.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 potrebbe darti un warning.
In realtà credo che con l'ultimo standard (C99) la funzione main non si
sottragga allo stesso trattamento delle funzioni normali: il tipo di
ritorno deve essere *sempre* dichiarato, non c'è più l'assunzione
automatica del tipo int.


 indispensabile che vi sia una return.
A dire il vero, secondo la mia copia del C99 le cose non stanno proprio
cosě:
<<5.1.2.2.1 Program startup
The function called at program startup is named main. The implementation
declares no prototype for this function. It shall be defined with a return
type of int and with no parameters:
   int main(void) { /* ... */ }
or with two parameters (referred to here as argc and argv, though any names
may be used, as they are local to the function in which they are declared):
   int main(int argc, char *argv[]) { /* ... */ }
or equivalent; or in some other implementation-defined manner.>>
Quel "some other implementation-defined manner" lascia aperta la porta a
qualsiasi cosa. Infatti, poco dopo dice:
<<5.1.2.2.3 Program termination
If the return type of the main function is a type compatible with int, a
return from the initial call to the main function is equivalent to calling
the exit function with the value returned by the main function as its
argument; reaching the } that terminates the main function returns a value
of 0. If the return type is not compatible with int, the termination status
returned to the host environment is unspecified.>>
In teoria, dunque, il valore di ritorno non č necessariamente un int e
addirittura non č nemmeno necessariamente "compatible with int", cioč non č
necessariamente un tipo numerico. Ci potrebbe pure essere un compilatore
(folle!!!) che richiede che tu ritorni, che so, una certa struct...
Spero di scoprire dalla vostre risposte che la mia copia del C99 č obsoleta,
o che io non ho capito quel che ho letto, perché questo mi pare
l'"implementation-defined" piů fesso della storia del C.
--
Cingar
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 l'"implementation-defined" più fesso della storia del C.
C`e un po' troppo "burocratese". Quando descrive main dice "It shall be
defined...": questo implica che qualunque implementazione *deve*
supportare quelle due dichiarazioni per essere conforme. Guarda il
capitolo 4, primo punto:
4. Conformance
1) In this International Standard, shall is to be interpreted as a
requirement on an implementation or on a program; conversely, shall not
is to be interpreted as a prohibition.
La parte "implementation-defined" ammette che delle implementazioni (ie.
un certo compilatore su una certa macchina) possa accettare
dichiarazioni differenti:
3.4.1 
1) implementation-defined behavior unspecified behavior where each
implementation documents how the choice is made.
2) EXAMPLE An example of implementation-defined behavior is the
propagation of the high-order bit when a signed integer is shifted
right.
L'esempio e` significativo. Posso usare l'operatore di shift con un
numero signed ed aspettarmi che funzioni come descritto nel manuale del
mio compilatore. Ma non posso aspettarmi che un altro compilatore si
comporti nello stesso modo. In altre parole un programma strettamente
conforme allo standard non puo` fare affidamente su comportamenti
implementation-defined perche` (per loro natura) sono validi solo su una
particolare implementazione. Tornando al capitolo 4:
5) A strictly conforming program shall use only those features of the
language and library specified in this International Standard. It shall
not produce output dependent on any unspecified, undefined, or
implementation-defined behavior, and shall not exceed any minimum
implementation limit.
Al niubbo di turno di solito si evita questa parte, gli si dice di usare
int e basta. Qualcuno che volesse usare qualcosa di diverso da int per
validi motivi di solito sa quello a cui va incontro e non chiede qui`.
Spero di aver chiarito il tuo dubbio,
Luca
-- 
Home: 
http://kronoz.cjb.net
Il coraggio non mi manca.
E` la paura che mi frega...

 Spero di aver chiarito il tuo dubbio,
Sì, direi che la tua interpretazione è decisamente più sensata della mia.
Meglio così!
