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

Salve,
Sul K&R la funzione main viene definita come da oggetto ovvero:
main()
{
...
}
La domanda è questa: é standard fare in questo modo?non si dovrebbe fare:
int main(void)
         {
            ...........
              return 0;
          }
??
ciao by JSMR
------------------------------------------------------
La forza di un guerriero si valuta dalla forza del nemico

 ??
Il K&R si riferisce allo standard C89 (che e` ancora quello piu` 
diffuso). In C89 main() e` legale, e anche int main(void) lo e`.
Lo standard C99 invece richiede esplicitamente int main(void).
Ergo, la cosa migliore secondo me e` dichiarala come int main(void),
cosi` e` conforme ad entrambi gli standard.
Per quanto riguarda invece il return 0, in effetti nelle prime pagine 
del K&R questo e` omesso. Si tratta effettivamente di un errore in C89 
(o probabilmente di una reminiscenza del C pre-standard). Dopo il 
discorso sulle funzioni nel capitolo introduttivo, comunque, viene messo 
un return 0 anche nella funzione main.
In C99 invece il return 0 alla fine di main e` eseguito anche se non 
indicato esplicitamente (cosa, in ogni caso, lecita).
Per prendere due piccioni con una fava anche in questo caso, basta 
mettere sempre il return 0.
Il tuo secondo esempio e` quindi probabilmente la maniera migliore in 
assoluto di scrivere main, in quanto conforme allo standard attuale, ma 
anche a quello precedente, da entrambi i punti di vista.

Attaccandomi a quello che ha detto Enrico, molti prof universitari cercano
di farti prendere la buona abitudine di mettere sempre il valore di ritorno
se la funzione non è void e ti segnano (giustamente in quest'ottica) errore
se dichiari main() e non metti il return.
Tra l'altro in questo senso è sempre buona abitudine abilitare i warning nel
compilatore -Wall in modo che lui stesso ti segnali che c'è una funzione
nella quale manca il valore di ritorno
se no tanto vale mettere void main() e chiusa li :)

Thx..... ora č molto piu chiaro.
Un ultima cosa... gli argomenti di main argv.. ecc.. devono essere messi
nella definizione di funzione solo se devo utilizzarli?
ciauz
-------------------------------------------
Non fare domani quello che puoi fare oggi.

 nella definizione di funzione solo se devo utilizzarli?
Conta che in C, se non sbaglio, non mettere argomenti significa 
"qualunque numero di argomenti" - il che elimina il type checking (anche 
se in questo caso e' abbastanza inutile). Quindi in generale e' meglio 
mettere un int main(void) quando non usi gli argomenti, un int main(int 
argc, char *argv[]) quando li usi.
-- 
/**
  * Mattia Belletti - Undergraduate student @ 
cs.unibo.it
  * ICQ: 33292311   - email: 
mbel...@cs.unibo.it
  * IRC: BluShine   - site(s): 
http://cs.unibo.it/~mbellett
  * Linux registered user 299762 @ Linux registered machine 213003
  */

 "qualunque numero di argomenti"
Non so se in C99 hanno reso la regola uniforme a quella del C++
(Kronos ?!).
Questa è una delle regole che rende diversa la semantica del C e del
C++.
In C++ non scrivere argomenti tra parentesi significa "nessun
argomento".

 argc, char *argv[]) quando li usi.
Concordo in pieno sull'ultima cosa.
Paolo

 (Kronos ?!).
Ah,  lo  standard e`  abbastanza  complesso  in  questo campo,  per  non
compromettere  la compatibilita`  con  il C89. Queste  sono le  porzioni
rilevanti:
6.7.5 Declarators
Syntax 1
direct-declarator:
        direct-declarator ( parameter-type-list ) 
        direct-declarator ( identifier-listopt )
La prima forma e` quella pre-ANSI, la seconda e` quella normalmente
usata.
6.7.5.3 Function declarators (including prototypes)
Constraints
[...]
3) An  identifier list in  a function declarator that  is not part  of a
definition of that function shall be empty.
Quindi,  se usiamo  la forma  pre-ANSI allora  una dichiarazione  di una
funzione *deve* avere la lista degli identificatori vuota.
Semantics
[...]
14) An identifier  list declares only the identifiers  of the parameters
of the function. An empty list in  a function declarator that is part of
a  definition  of that  function  specifies  that  the function  has  no
parameters. The empty list in a function  declarator that is not part of
a definition  of that function  specifies that no information  about the
number or types of the parameters is supplied.
La dichiarazione pre-ANSI di una funzione non da alcuna informazione sul
tipo e  sul numero  dei parametri. In un  definizione, invece,  la lista
vuota e` equivalente a void.
Delle note rimandano a:
6.11.6 Function declarators 
1)  The  use  of  function   declarators  with  empty  parentheses  (not
prototype-format parameter type declarators) is an obsolescent feature.
6.11.7 Function definitions 
1) The  use of function  definitions with separate  parameter identifier
and declaration lists
Proseguendo:
6.9.1 Function definitions
[...]
5) If the declarator includes a  parameter type list, the declaration of
each parameter shall include an  identifier, except for the special case
of a  parameter list consisting of  a single parameter of  type void, in
which case there  shall not be an identifier. No  declaration list shall
follow.
Se usiamo il formato "nuovo" allora void *deve* essere presente,
altrimenti si rientra nel caso di definizione obsoleta.
Semantics
[...]
7) The  declarator in a  function definition  specifies the name  of the
function being  defined and  the identifiers  of its  parameters. If the
declarator includes a  parameter type list, the list  also specifies the
types of all the parameters; such a declarator also serves as a function
prototype for later  calls to the same function in  the same translation
unit. If the  declarator includes an  identifier list, the types  of the
parameters shall be declared in  a following declaration list. In either
case, the type of each parameter is adjusted as described in 6.7.5.3 for
a parameter type list; the resulting type shall be an object type.
Luca
-- 
Home: 
http://kronoz.cjb.net
Un apostolo vedendo Gesu` camminare sulle acque:
- Cazzo se e` buono 'sto fumo!!!