What is the proper declaration of main in C++?

c++, c++-faq, function, language-lawyer, program-entry-point

Solution

The `main` function must be declared as a non-member function in the global namespace. This means that it cannot be a static or non-static member function of a class, nor can it be placed in a namespace (even the unnamed namespace).

The name `main` is not reserved in C++ except as a function in the global namespace. You are free to declare other entities named `main`, including among other things, classes, variables, enumerations, member functions, and non-member functions not in the global namespace.

You can declare a function named `main` as a member function or in a namespace, but such a function would not be the `main` function that designates where the program starts.

The `main` function cannot be declared as `static` or `inline`. It also cannot be overloaded; there can be only one function named `main` in the global namespace.

The `main` function cannot be used in your program: you are not allowed to call the `main` function from anywhere in your code, nor are you allowed to take its address.

The return type of `main` must be `int`. No other return type is allowed (this rule is in bold because it is very common to see incorrect programs that declare `main` with a return type of `void`; this is probably the most frequently violated rule concerning the `main` function).

There are two declarations of `main` that must be allowed:

int main()               // (1)
int main(int, char*[])   // (2)

In (1), there are no parameters.

In (2), there are two parameters and they are conventionally named `argc` and `argv`, respectively. `argv` is a pointer to an array of C strings representing the arguments to the program. `argc` is the number of arguments in the `argv` array.

Usually, `argv[0]` contains the name of the program, but this is not always the case. `argv[argc]` is guaranteed to be a null pointer.

Note that since an array type argument (like `char*[]`) is really just a pointer type argument in disguise, the following two are both valid ways to write (2) and they both mean exactly the same thing:

int main(int argc, char* argv[])
int main(int argc, char** argv)

Some implementations may allow other types and numbers of parameters; you'd have to check the documentation of your implementation to see what it supports.

`main()` is expected to return zero to indicate success and non-zero to indicate failure. You are not required to explicitly write a `return` statement in `main()`: if you let `main()` return without an explicit `return` statement, it's the same as if you had written `return 0;`. The following two `main()` functions have the same behavior:

int main() { }
int main() { return 0; }

There are two macros, `EXIT_SUCCESS` and `EXIT_FAILURE`, defined in `<cstdlib>` that can also be returned from `main()` to indicate success and failure, respectively.

The value returned by `main()` is passed to the `exit()` function, which terminates the program.

Note that all of this applies only when compiling for a hosted environment (informally, an environment where you have a full standard library and there's an OS running your program). It is also possible to compile a C++ program for a freestanding environment (for example, some types of embedded systems), in which case startup and termination are wholly implementation-defined and a `main()` function may not even be required. If you're writing C++ for a modern desktop OS, though, you're compiling for a hosted environment.

Problem

Original source

Related problems

• What should main() return in C and C++?
• What should main() return in C and C++?