In the main function of a C++ program, what does `return 0` do and mean?

Question

Possible Duplicate:
What is the proper declaration of main?

Without citing any code in particular, I am looking for an explanation of the below example:

#include <iostream>

int main()
{
    std::cout << "Hello world" << std::endl;
    return 0;
}

I don't understand what return 0 does. Can you please explain this in as plain English as possible?

Answer 1

This defines the exit status of the process. Despite being an int, on Unix-like systems, the value is always in the range 0-255 (see Exit and Exit Status). On Microsoft systems you may use 32-bit signed integers as exit codes, which you can check with %ERRORLEVEL%. For portability, I'd recommend sticking to the 0-255 range.

Here is a trivial example:

$ cat -n exit_code.cpp 
     1  int main()
     2  {
     3      return 42;
     4  }
     5  

Build:

$ make exit_code
g++ exit_code.cpp -o exit_code

Run (in bash):

$ ./exit_code

Check the exit status:

$ echo $?
42

Conventionally, a status of zero signifies success and non-zero failure. This can be useful in shell scripts, and so forth to indicate the level of failure, if any:

$ ./exit_code
exit_status=$?
if [[ ${exit_status} ]] ; then
    echo "The process failed with status ${exit_status}."
else
    echo "Success!"
fi
The process failed with status 42.

---

Following the comments below...

In the standard C++ header <cstdlib>, the following macros are defined:

#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1

However, the Exit Status section of the GNU C Library documentation, describing the same macros, sagely states:

Portability note: Some non-POSIX systems use different conventions for exit status values. 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 file stdlib.h.

Answer 2

General returning

Every function has a return type.

In the below example, the type is void, which is an "incomplete type" with no values; using this as the return type means that the function returns no value:

void foo() {
   std::cout << "Hello world\n";
}

However, in the below example, the return type is int:

int foo() {
   return 3;
}

The return statement determines what value calls to function foo will evaluate to. So, std::cout << foo() will result in "3" being printed to standard output.

---

returning from main, specifically

When the function in question happens to be the "main" function, or the program's entrypoint, it's a bit more special, because the "return value" of the "main" function is taken to be the program's "exit code" — it tells the calling environment (e.g. terminal session) whether the program's execution was deemed to be successful. It must be an int, and a value of 0 here means "everything went fine":

It's worth noting that you can actually completely omit return 0; in the "main" function as it will be included implicitly. This doesn't help you much, though, if you want to return 1; or some other value, and it doesn't come into play with other functions.

---

Citations

[C++11: 3.6.1/5]: A return statement in main has the effect of leaving the main function (destroying any objects with automatic storage duration) and calling std::exit with the return value as the argument. If control reaches the end of main without encountering a return statement, the effect is that of executing return 0;

[C++11: 18.5/8]:

       [[noreturn]] void exit(int status)

The function exit() has additional behavior in this International Standard:

• First, objects with thread storage duration and associated with the current thread are destroyed.
  Next, objects with static storage duration are destroyed and functions registered by calling atexit are called. See 3.6.3 for the order of destructions and calls. (Automatic objects are not destroyed as a result of calling exit().)
  If control leaves a registered function called by exit because the function does not provide a handler for a thrown exception, terminate() shall be called (15.5.1).
• Next, all open C streams (as mediated by the function signatures declared in <cstdio>) with unwritten buffered data are flushed, all open C streams are closed, and all files created by calling tmpfile() are removed.
• Finally, control is returned to the host environment. If status is zero or EXIT_SUCCESS, an implementation-defined form of the status successful termination is returned. If status is EXIT_FAILURE, an implementation-defined form of the status unsuccessful termination is returned. Otherwise the status returned is implementation-defined.

---

Bootnote

_{I suggest one of these resources, as this sort of thing is explained properly in any decent peer-reviewed C++ book; YouTube tutorials are not a good way to learn C++, and Stack Overflow contributors will generally expect you to have a decent book to form your prior research before resorting to asking for help.}

Answer 3

It's used because you may use your program as a command line tool. If there is another process waiting for the output of your program you may choose to return 0 if everything is successful, -1 if there was an error or any other constant, according to what you want to communicate.

Answer 4

Think of your boss telling you to go pick up the mail. After you pick up the mail, you tell your boss that everything went okay.

The operating system is the boss, the program is you. And all return 0 does is tells the operating system that everything went okay.

Answer 5

Under windows you can test for return value as follows (in batch script):

MyAppTest.exe
@if "%ERRORLEVEL%" == "0" goto success
 echo Failure
 goto end
:success
 echo Success
:end

Answer 6

Returning from main() has the same effect as calling std::exit() and passing the return value as the status parameter.

The behavior of std::exit is detailed in section 18.5 ([support.start.term]), and describes the status code:

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

Answer 7

return is used to escape the function. Returning the value 0 simply allows it to exit with a code: 0. Also, returning with 0 claims a successful exit of the application.

Answer 8

0 is an integer.

Your main function has to return an integer.

Just look at:

int main()

int stands for integer and return in this case, returns 0: an integer to terminate the program.

Usually for an error you have to return 1; 0 is the conventional value for success.

Answer 9

Depends on operating system, but an exit code of 0 means success on UNIX, VMS and Windows

Answer 10

The return value from the main function is returned to the calling application or process (a lot of times this is a shell script). The return value is used to signal the exit status of the application.

There are no hardened rules at to what the return value should be but, by convention a return value of zero signifies normal application exit. Any non-zero value signifies abnormal application exit.

Answer 11

In simple applications like yours the returned value means nothing. If there is an observing process (like if one program launches another) it can be an easy way to get communicate a status or error code.

For a simple application which does not have an status or error codes, most people return 0 for a normal application exit (usually success) and return 1 if the app. fails to properly execute.

Answer 12

On a modern operating system, every program will exit with a specific "exit code".

DISCLAIMER NO 1.: The actual specification of that concept (of having an exit code at all) is out of the scope of any programming language specification at all. So: ANYONE asking me again about a reference to a standard may please retreat into itself, and think about a better answer for the moment.

DISPLAIMER NO 2.: The actual values of those exit codes are not specified in not actual "programming language specification", because that is out of the scope of a "programming language specification".

So long, practice has shown, that an exit code of "0" means "success", and any other code signals an error...