6 Basics [basic]

6.9 Program execution [basic.exec]

6.9.3 Start and termination [basic.start]

6.9.3.1 main function [basic.start.main]

A program shall contain a global function called main attached to the global module.

Executing a program starts a main thread of execution ([intro.multithread], [thread.threads]) in which the main function is invoked.

It is implementation-defined whether a program in a freestanding environment is required to define a main function.

[Note 1:

In a freestanding environment, startup and termination is implementation-defined; startup contains the execution of constructors for objects of namespace scope with static storage duration; termination contains the execution of destructors for objects with static storage duration.

— end note]

An implementation shall not predefine the main function.

This function shall not be overloaded.

Its type shall have C++ language linkage and it shall have a declared return type of type int, but otherwise its type is implementation-defined.

An implementation shall allow both

(2.1)
a function of () returning int and
(2.2)
a function of (int, pointer to pointer to char) returning int

as the type of main ([dcl.fct]).

In the latter form, for purposes of exposition, the first function parameter is called argc and the second function parameter is called argv, where argc shall be the number of arguments passed to the program from the environment in which the program is run.

If argc is nonzero these arguments shall be supplied in argv[0] through argv[argc-1] as pointers to the initial characters of null-terminated multibyte strings (ntmbss) ([multibyte.strings]) and argv[0] shall be the pointer to the initial character of a ntmbs that represents the name used to invoke the program or "".

The value of argc shall be non-negative.

The value of argv[argc] shall be 0.

[Note 2:

It is recommended that any further (optional) parameters be added after argv.

— end note]

The function main shall not be used within a program.

The linkage ([basic.link]) of main is implementation-defined.

A program that defines main as deleted or that declares main to be inline, static, or constexpr is ill-formed.

The function main shall not be a coroutine ([dcl.fct.def.coroutine]).

The main function shall not be declared with a linkage-specification ([dcl.link]).

A program that declares a variable main at global scope, or that declares a function main at global scope attached to a named module, or that declares the name main with C language linkage (in any namespace) is ill-formed.

The name main is not otherwise reserved.

[Example 1:

Member functions, classes, and enumerations can be called main, as can entities in other namespaces.

— end example]

Terminating the program without leaving the current block (e.g., by calling the function std::exit(int) ([support.start.term])) does not destroy any objects with automatic storage duration ([class.dtor]).

If std::exit is called to end a program during the destruction of an object with static or thread storage duration, the program has undefined behavior.

A return statement ([stmt.return]) in main has the effect of leaving the main function (destroying any objects with automatic storage duration) and calling std::exit with the return value as the argument.

If control flows off the end of the compound-statement of main, the effect is equivalent to a return with operand 0 (see also [except.handle]).