2

In C, a function always returns its value to the calling function and never to itself (if return type is not void). Like,

int main()

But since 'main' function is called by the Operating System, which is not a function. So, whom does the 'main' function returns its value? Where does the value go, when its returned using the expression 

return(0);

at the end of the program?

Keith Thompson
  • 254,901
  • 44
  • 429
  • 631
bivs06
  • 21
  • 1
  • 2
  • 2
    Typically, the OS makes it available to the parent of your process, (e.g. in `bash` go `./yourprogram; echo $?` – M.M Aug 21 '14 at 20:03
  • 2
    A return type of `void` is system-specific. Compilers are permitted, but not required to accept return types for `main` other than `int` -- and unless you're on a freestanding (embedded) implementation, there is simply no good reason to define `main` with a return type other than `int`. Just add a `return 0;` at the end -- or you can omit it if your compiler supports C99 or later. (Some C textbooks recommend using `void main()`. *Good* C textbooks do not.) – Keith Thompson Aug 21 '14 at 20:07
  • 2
    And `int main()` is better written as `int main(void)`. – Keith Thompson Aug 21 '14 at 20:11
  • 1
    Related question. What calls main? http://stackoverflow.com/questions/3469955/in-c-how-is-the-main-method-initially-called – hookenz Aug 21 '14 at 20:15
  • In most cases, `/dev/null` – leppie Aug 21 '14 at 20:25
  • @leppie there's no `/dev/null` in Windows and many other OSes – phuclv Jan 08 '17 at 08:54
  • Possible duplicate of [main() functions return value?](http://stackoverflow.com/questions/4818888/main-functions-return-value) – phuclv Jan 08 '17 at 08:57

4 Answers4

4

This is completely OS-specific, but usually the OS invokes a program by

  1. Setting up the program's address space,
  2. Creating a record of the new process somewhere in the OS internals,
  3. Launching its own custom function, which calls main and stores the return value in the OS internals.

The function I'm referring to in (3) is often a good old fashioned C function that just jumps into main so it can capture the return value from main as if it were an ordinary C function (which it in fact is). Afterwards, it stores that value somewhere in OS-land so that processes that need to read the return value can do so.

Hope this helps!

templatetypedef
  • 362,284
  • 104
  • 897
  • 1,065
4

As already said, this is OS specific. In UNIX systems it looks something like this:

When you compile a program with gcc, it wraps a startup routine around your main() function. This routine calls your main() function and saves its return value. It then calls the exit() function (which your program might call as well), that does some general clean up. This function then again calls _exit(), which is a system call that tells the OS to save the returned value of your main() function in the process table (where meta information about your process is saved). As soon as another process calls wait() on your process id (PID), your returned value is given to the calling process and your process is removed from the table.

Look at this resource for more information: http://www.johnloomis.org/ece537/notes/Processes/process_environment.html

glglgl
  • 89,107
  • 13
  • 149
  • 217
Philipp Murry
  • 1,660
  • 9
  • 13
1

Where does the returned value for 'main' function go?

It is returned to the calling process.

On a POSIX compliant systems if the calling parent process were a C program it could at least retrieve the lowest 8bit of its child's return value by calling wait() or waitpid() after the child ended.

glglgl
  • 89,107
  • 13
  • 149
  • 217
alk
  • 69,737
  • 10
  • 105
  • 255
0

most operating systems call main like this:

exit(main(argc, argv, envp));

programmerjake
  • 1,794
  • 11
  • 15