Main function - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Main function

From cppreference.com
< cpp‎ | language

A program shall contain a global function called `main`, which is the designated start of the program.

int `main` `()` `{` body `}` | (1) |
int `main` `(`int argc`,` char *argv[]`)` `{` body `}` | (2) |
int `main` `(`int argc`,` char *argv[] `,` other_parameters `)` `{` body `}` | (3) |

argc | - | Non-negative value representing the number of arguments passed to the program from the environment in which the program is run.
argv | - | Pointer to an array of pointers to null-terminated multibyte strings that represent the arguments passed to the program from the execution environment (argv[0] through argv[argc-1]). The value of argv[argc] is guaranteed to be ​0​.
body | - | The body of the main function
other_parameters | - | Implementations may allow additional forms of the main function as long as the return type remains `int`. A very common extension is passing a third argument of type `char*[]` pointing at an array of pointers to the execution environment variables.

The names `argc` and `argv` are arbitrary, as well as the representation of the types of the parameters: int main(int ac, char** av) is equally valid.

### [edit] Explanation

The `main` function is called at program startup after initialization of the non-local objects with static storage duration. It is the designated entry point to a program that is executed in hosted environment (that is, with an operating system). The entry points to freestanding programs (boot loaders, OS kernels, etc) are implementation-defined.

The parameters of the two-parameter form of the main function allow arbitrary multibyte character strings to be passed from the execution environment (these are typically known as command line arguments), the pointers `argv[1] .. argv[argc-1]` point at the first characters in each of these strings. `argv[0]` is the pointer to the initial character of a null-terminated multibyte strings that represents the name used to invoke the program itself (or an empty string "" if this is not supported by the execution environment). The strings are modifiable, although these modifications do not propagate back to the execution environment: they can be used, for example, with std::strtok. The size of the array pointed to by `argv` is at least `argc+1`, and the last element, `argv[argc]`, is guaranteed to be a null pointer.

The `main` function has several special properties:

1) It cannot be used anywhere in the program
a) in particular, it cannot be called recursively
b) its address cannot be taken
2) It cannot be predefined and cannot be overloaded: effectively, the name `main` in the global namespace is reserved for functions (although it can be used to name classes, namespaces, enumerations, and any entity in a non-global namespace)
3) It cannot be defined as deleted or declared inline, static, or constexpr
4) The body of the main function does not need to contain the return statement: if control reaches the end of `main` without encountering a return statement, the effect is that of executing return 0;.
5) Execution of the return (or the implicit return upon reaching the end of main) is equivalent to first leaving the function normally (which destroys the objects with automatic storage duration) and then calling std::exit with the same argument as the argument of the return. (std::exit then destroys static objects and terminates the program)
6) If the main function is defined with a function-try-block, the exceptions thrown by the destructors of static objects (which are destroyed by the implied std::exit) are not caught by it.
7) (since C++14) The return type of the main function cannot be deduced (auto main() {... is not allowed)

### [edit] See also

C documentation for main function

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/language/main_function&oldid=72095"