Return value range of the main function
As others have stated, the C & C++ Standards don't constrain return values at all other than to state that
main()returns anint(which is of an implementation defined size), and- zero (or
EXIT_SUCCESS) is a successful return andEXIT_FAILUREis a non-successful return.
It does specify that a main() that does explicitly not return a value is treated as if it had returned zero.
In this case, the interpretation of the return value is up to the process that waits on the process to complete (by calling wait(), waitpid(), or waitid()). wait() and waitpid() are the older POSIX functions and they specify that only the least significant eight bits of the return value shall be available to a waiting parent process. The POSIX:2008 standard added waitid() as a generalized wait method that has access to the full exit status of a child process.
After forking off a subprocess, the parent process calls one of the wait*() functions to sleep until the forked process is completed (e.g., returns from main(), calls exit() or abort() or something). The wait() and waitpid() functions return the status by way of a pointer to an integer. The caller extracts the actual exit status using the WIFEXITED(status_val) and WEXITSTATUS(status_val) macros. The latter is defined by POSIX and required to return the low-order 8 bits of the status argument. The waitid() function uses a pointer to a siginfo_t structure to return the process's status information. The si_status member contains the full status value as described in Status Information.
Basically, the values of the exit status are in the eye of the beholder. The ANSI/ISO specifications are open-ended. The POSIX suite has multiple ways to wait on a process to finish and fetch it's exit status. POSIX also defines spawn() as a lighter-weight version of exec() which has its own set of constraints on exit status values. Shells have a habit of further restricting result values -- GNU's bash limits the return status to 7 bits and a POSIX-compliant shell limits exit status values to 8 bits. FWIW, most people agree that restricting your return values to be lower than 64 seems to be safe.
The standard doesn't say. 0, EXIT_SUCCESS and EXIT_FAILURE have (sort of) specified meanings. Anything else depends on the implementation.
At the present time, most Unix-based systems only support 8-bit return values. Windows supports (at least) a 32-bit return value. I haven't checked whether 64-bit Windows supports a 64-bit return value, but I rather doubt it, since even 64-bit Windows normally still uses a 32-bit int.
Exit codes are a number between 0 and 255 inclusive on Unix like system. You can return anything but in Linux it's modded 256. Take a peek here for a good explanation on Linux return codes. There is also a Wikipedia article on the topic which talks breifly about exit codes for Windows.
The C standard do not impose particular limitation on exit codes, the paragraph about the return value of main delegates to the documentation about the exit() function, which in turn says:
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 isEXIT_FAILURE, an implementation-defined form of the status unsuccessful termination is returned. Otherwise the status returned is implementation-defined.
which, apart from the EXIT_SUCCESS/EXIT_FAILURE guidelines, basically means "do whatever you want". :)
As said in one comment, the fact that on POSIX systems only the lower 8 bits of the exit code are actually considered is just a UNIXism, deriving from how the wait syscall is designed (the exit status has to be packed in the lower 8 bits of the wait return value), and has nothing to do with the C standard.
A counterexample is Windows, where the whole value passed to exit/return is considered (as long as it's not bigger than a DWORD1, but I don't think they'll ever make int be bigger than a DWORD, it would break a lot of code).
1. Because the
GetExitCodeProcess parameter reserved for returning this value is a DWORD *.