Styles of main functions in C [duplicate]

Question

Possible Duplicate:
What is the proper declaration of main?

I am working on my C skills and I have noticed that

int main( int argc, char *argv[] )

and

return (EXIT_SUCCESS)

instead of

int main() and return 0

Why is this?

Answer 1

int main (int argc, char * argv []) is for when you want to take command line arguments.

EXIT_SUCCESS is just a #define that's more descriptive than 0.

Answer 2

Operating Systems can differ in how a program indicates successful operation. The macro EXIT_SUCCESS ideally expands to a value appropriate for the system the program is compiled for.

http://en.wikipedia.org/wiki/Exit_status

Answer 3

(The two things you ask have nothing to do with each other.)

To answer your first question: Having int main() just means that the program is not accepting command line arguments. When it takes the two arguments, argc is the argument count (it will always be greater than or equal to one, since the first argument will be the path or name of the program itself), and argv is the list of arguments.

To answer your second question: EXIT_SUCCESS is guaranteed to be interpreted as success by the underlying operating system.

Answer 4

If you are going to ignore the argument list, it is reasonable and sensible to use:

int main(void) { ... }

The standards bless this usage, as well as the one with arguments. You get a warning from GCC if you compile with -Wstrict-prototypes and don't include the void, so I write the void. C++ is different here.

As for return EXIT_SUCCESS;, there seems to be little benefit to it in general; I continue to write return 0; at the end of a main() function, even though C99 permits you to omit any return there (and it then behaves as if you wrote return 0;).

ISO/IEC 9899:1999

§5.1.2.2.1 Program startup

¶1 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.

⁹⁾ Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as char ** argv, and so on.

§5.1.2.2.3 Program termination

¶1 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 accordance with §6.2.4, the lifetimes of objects with automatic storage duration declared in main will have ended in the former case, even where they would not have in the latter.

§7.20.4.3 The exit function

¶5 Finally, control is returned to the host environment. If the value of status is zero or EXIT_SUCCESS, an implementation-defined form of the status successful termination is returned. If the value of status is EXIT_FAILURE, an implementation-defined form of the status unsuccessful termination is returned. Otherwise the status returned is implementation-defined.

Aside: Note that §5.1.2.2.3 clearly indicates that the C standard allows an implementation to permit return types for main() other than int (unlike the C++ standard, which expressly forbids a return type other than int). However, as Jens rightly points out, a non-int return type from main is only allowed if the implementation explicitly documents that it is allowed, and the documentation will probably place limits on what is allowed.

Answer 5

int main( int argc, char *argv[] ) allows the user input arguments at the execution of the program, i.e., that text you write in the console after the program name.

return (EXIT_SUCCESS) is in case an O.S. doesn't expect 0 as a value of successful exit: it would be any other value, but in most cases, EXIT_SUCCESS equals 0.