Should I return EXIT_SUCCESS or 0 from main()?
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.)
Proper way to return from main
As methods of terminating a program, return
and exit
are closely related. In fact, the statement
return EXIT_SUCCESS;
in main
is equivalent to
exit (EXIT_SUCCESS);
The difference between return
and exit
is that exit
causes program termination regardless of which function calls it. The return
statement causes program termination only when it appears in the main
function.
Why default return value of main is 0 and not EXIT_SUCCESS?
Returning zero from main()
does essentially the same as what you're asking. Returning zero from main()
does not have to return zero to the host environment.
From the C90/C99/C++98 standard document:
If the value of status is zero or
EXIT_SUCCESS
, an implementation-defined form of the status successful termination is returned.
Why return 0 from main() in a C program?
It returns the 0 to OS to tell the OS that your program executed successfully.
Difference between system( PAUSE) return EXIT_SUCCESS and return 0
EXIT_SUCCESS
is a constant for the successfull execution of the program. See here
#define EXIT_SUCCESS 0 /* Successful exit status. */
The command system("PAUSE")
generate a command line pause (only for Windows!). So this command is indepentend of your return 0
or return EXIT_SUCCESS
.
return statement vs exit() in main()
Actually, there is a difference, but it's subtle. It has more implications for C++, but the differences are important.
When I call return
in main()
, destructors will be called for my locally scoped objects. If I call exit()
, no destructor will be called for my locally scoped objects! Re-read that. exit()
does not return. That means that once I call it, there are "no backsies." Any objects that you've created in that function will not be destroyed. Often this has no implications, but sometimes it does, like closing files (surely you want all your data flushed to disk?).
Note that static
objects will be cleaned up even if you call exit()
. Finally note, that if you use abort()
, no objects will be destroyed. That is, no global objects, no static objects and no local objects will have their destructors called.
Proceed with caution when favoring exit over return.
http://groups.google.com/group/gnu.gcc.help/msg/8348c50030cfd15a
Should I return 0 or 1 for successful function?
It's defined by the C standard as 0
for success (credits go to hvd).
But
For greater portability, you can use the macros
EXIT_SUCCESS
and
EXIT_FAILURE
for the conventional status value for success and
failure, respectively. They are declared in the filestdlib.h
.
(I'm talking about the value returned to the OS from main, exit or similar calls)
As for your function, return what you wish and makes code more readable, as long as you keep it that way along your programs.
Related Topics
How to Delete an Element from a Vector While Looping Over It
Declaring Multiple Object Pointers on One Line Causes Compiler Error
Construct Path for #Include Directive with MACro
Why Stdfax.H Should Be the First Include on Mfc Applications
Understanding Recursion to Generate Permutations
Compile the Python Interpreter Statically
Linker Error While Linking Boost Log Tutorial (Undefined References)
C++: Is It Safe to Cast Pointer to Int and Later Back to Pointer Again
C++ Memory Model and Race Conditions on Char Arrays
C++ String to Double Conversion
Building and Accessing a List of Types at Compile Time
Why Are Redundant Scope Qualifications Supported by the Compiler, and Is It Legal
Constant References with Typedef and Templates in C++
How to Reset Std::Cin When Using It
How to Reliably Get an Object's Address When Operator& Is Overloaded