Should I return EXIT_SUCCESS or 0 from main()?
Solution 1:
EXIT_FAILURE
, either in a return statement in main
or as an argument to exit()
, is the only portable way to indicate failure in a C or C++ program. exit(1)
can actually signal successful termination on VMS, for example.
If you're going to be using EXIT_FAILURE
when your program fails, then you might as well use EXIT_SUCCESS
when it succeeds, just for the sake of symmetry.
On the other hand, if the program never signals failure, you can use either 0
or EXIT_SUCCESS
. Both are guaranteed by the standard to signal successful completion. (It's barely possible that EXIT_SUCCESS
could have a value other than 0, but it's equal to 0 on every implementation I've ever heard of.)
Using 0
has the minor advantage that you don't need #include <stdlib.h>
in C, or #include <cstdlib>
in C++ (if you're using a return
statement rather than calling exit()
) -- but for a program of any significant size you're going to be including stdlib directly or indirectly anyway.
For that matter, in C starting with the 1999 standard, and in all versions of C++, reaching the end of main()
does an implicit return 0;
anyway, so you might not need to use either 0
or EXIT_SUCCESS
explicitly. (But at least in C, I consider an explicit return 0;
to be better style.)
(Somebody asked about OpenVMS. I haven't used it in a long time, but as I recall odd status values generally denote success while even values denote failure. The C implementation maps 0
to 1
, so that return 0;
indicates successful termination. Other values are passed unchanged, so return 1;
also indicates successful termination. EXIT_FAILURE
would have a non-zero even value.)
Solution 2:
It does not matter. Both are the same.
C++ Standard Quotes:
If the value of status is zero or EXIT_SUCCESS, an implementation-defined form of the status successful termination is returned.
Solution 3:
0 is, by definition, a magic number. EXIT_SUCCESS is almost universally equal to 0, happily enough. So why not just return/exit 0?
exit(EXIT_SUCCESS); is abundantly clear in meaning.
exit(0); on the other hand, is counterintuitive in some ways. Someone not familiar with shell behavior might assume that 0 == false == bad, just like every other usage of 0 in C. But no - in this one special case, 0 == success == good. For most experienced devs, not going to be a problem. But why trip up the new guy for absolutely no reason?
tl;dr - if there's a defined constant for your magic number, there's almost never a reason not to used the constant in the first place. It's more searchable, often clearer, etc. and it doesn't cost you anything.