Canonical Form
The canonical prototype of main() is as follows:
int main()
The return value is the exit code of the process. Although it's of type
int, only the eight lowest bits of this value are significant. Put
differently, the valid range of values that main() may return is -128
through 127. A return value of 0 indicates success; any other value
indicates an error of some sort. All negative exit statuses are reserved
for processes that are terminated by other processes or by the kernel
(e.g., due to a signal). A positive value indicates a user-defined error
code.
In pre-standard C, a function with no explicit return value would return
int implicitly. This deprecated convention is still supported, though
it's best avoided. Programs that declare main() as follows are accepted
by most compilers:
main()
Note that such programs do return an implicit exit status because the
kernel stores each process's exist status in a special table.
Command Line Arguments
main() has a second canonical form that enables you to access command
line arguments:
int main(int argc, char * argv[])
The argc argument is the total number of arguments passed. It shall not
be negative. argv is an array of pointers to the argument strings The
first argument, argv[0], contains the executable's name. Whether it's
the full pathname or not is implementation-dependent. argv[argc-1] is
the last argument and argv[argc] is NULL. Remember: if your program
doesn't access command line arguments, you should use the prototype:
int main()
This form is safer and slightly more efficient than
int main(int argc, char * argv[])
Passing an Environment
The standard recommends that additional parameters to main() be declared
after the canonical argc and argv. A common form of main() that takes a
third argument is:
int main(int argc, char * argv[], char *envp[])
The execle() and execve() functions enable you to pass a specific
environment to the newly launched process. envp contains the process's
environment in the form of an array of strings. Note that you can always
access the process's environment by accessing the global variable
environ, which is defined in <unsitd.h>. However, if you pass a special
environment to a process, using the third parameter envp makes your
intent more explicit and saves you the trouble of locating the
definition of environ.
