All About main()

Due to historical reasons, platform-dependent quirks, and

under-specification in pre-standard C, we are left with several valid

prototypes of main().

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


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:


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

. 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.
ITWorld DealPost: The best in tech deals and discounts.
Shop Tech Products at Amazon