What is the proper signature of the main function in C++?
What is the correct return type, and what does it mean to return a value from main?
What are the allowed parameter types, and what are their meanings?
Is this system-specific?
Have those rules changed over time?
What happens if I violate them?
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.
void main format a holdover from C? –
Chastise Main to be a static member function because it doesn't even have nonmember functions. Even C89 requires main to return int. I am not sufficiently familiar with K&R C to know its exact rules, but I would guess it also requires main to return int since main with no return type was somewhat common and no type = implicit int in K&R. –
Minter why the return type of main should be int? –
Chap int. –
Minter void ? –
Chap void return type.I have only used Visual studio c++ (and also the ancient turbo-c++ ) till now which passes my code. –
Chap void return type of main . (microsoft visual c++ 2010 express edition) –
Chap void return type as a language extension. Compilers that do not permit it include GCC and Comeau. –
Minter EXIT_SUCCESS and EXIT_FAILURE were only reliable as arguments to exit(). Returning either of them from main() could have unintended effects. Now that the standard has been clarified, there's no standard, portable way to return a completely arbitrary value to the host environment; you'd have to use a host-specific extension. –
Hallux From Standard docs., 3.6.1.2 Main Function,
It shall have a return type of type int, but otherwise its type is implementation-defined. All implementations shall allow both of the following definitions of main:
int main() { / ... / } and
int main(int argc, char* argv[]) { / ... / }
In the latter form
argcshall 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.....
Hope that helps..
main should be int ? –
Chap void breaks that model. It doesn't even really make sense if you had it mean "always deem success". Because you had no way of saying if the process actually failed, so did you really succeed? No, return int. –
Gilburt The two valid mains are int main() and int main(int, char*[]). Any thing else may or may not compile. If main doesn't explicitly return a value, 0 is implicitly returned.
main to be void. Is there any specific reason that return type of main should be int ? –
Chap int as the return type of main is that this value is handed to the shell as the program's exit code, and sh expects an int. –
Theodicy void they are all silent. With int we have to define the specific exit-value for each return from main. –
Pupil The exact wording of the latest published standard (C++14) is:
An implementation shall allow both
a function of
()returningintanda function of
(int, pointer to pointer tochar)returningintas the type of
main.
This makes it clear that alternative spellings are permitted so long as the type of main is the type int() or int(int, char**). So the following are also permitted:
int main(void)auto main() -> intint main ( )signed int main()typedef char **a; typedef int b, e; e main(b d, a c)int main(void) was not correct in C++. –
Turtleback auto main() -> int does not have a deduced return type. Pay attention to the { in "(auto main() {... is not allowed)" and please learn to know when you don't yet know enough to add anything meaningful. –
Absquatulate Details on return values and their meaning
Per 3.6.1 ([basic.start.main]):
A return statement in
mainhas the effect of leaving themainfunction (destroying any objects with automatic storage duration) and callingstd::exitwith the return value as the argument. If control reaches the end ofmainwithout encountering areturnstatement, the effect is that of executingreturn 0;
The behavior of std::exit is detailed in section 18.5 ([support.start.term]), and describes the status code:
Finally, control is returned to the host environment. If status is zero or
EXIT_SUCCESS, an implementation-defined form of the status successful termination is returned. If status isEXIT_FAILURE, an implementation-defined form of the status unsuccessful termination is returned. Otherwise the status returned is implementation-defined.
© 2022 - 2024 — McMap. All rights reserved.