Does it matter which way I declare the main function in a C++ (or C) program?
Add a comment
|
8 Answers
The difference is one is the correct way to define main, and the other is not.
And yes, it does matter. Either
int main(int argc, char** argv)
or
int main()
are the proper definition of your main per the C++ spec.
void main(int argc, char** argv)
is not and was, IIRC, a perversity that came with older Microsoft's C++ compilers.
Bjarne Stroustrup made this quite clear:
The definition
void main()is not and never has been C++, nor has it even been C.
See reference.
Comments
You should use int main. Both the C and C++ standards specify that main should return a value.
Comments
For C++, only int is allowed. For C, C99 says only int is allowed. The prior standard allowed for a void return.
In short, always int.
2 Comments
Dana the Sane
Returning an int is also required for C89.
Pryftan
The prior standard did not allow for a return of void. But one could leave off the return type and it would default to int. That still might work for some compilers. But that's not the same thing as void.
The point is, C programs (and C++ the same) always (should?) return a success value or error code, so they should be declared that way.
2 Comments
BitTickler
Yes? And who will use that return code in your mars rover bare metal device? :)
Svante
That is a useful question — as a zen koan.
A long time ago I found this page (void main(void)) which contained many reasons outside of the "the standard says it is not valid" argument. On particular operating systems/architectures it could cause the stack to become corrupted and or other nasty things to happen.
Comments
In C++, main() must return int. However, C99 allows main() to have a non-int return type. Here is the excerpt from the C99 standard.
5.1.2.2.1 Program startup
The function called at program startup is named main. The implementation declares no prototype for this function. It shall be defined with a return type of int and with no parameters:
int main(void) { /* ... */ }
or with two parameters (referred to here as argc and argv, though any names may be used, as they are local to the function in which they are declared):
int main(int argc, char *argv[]) { /* ... */ }
or equivalent; or in some other implementation-defined manner.
Also note that gcc does compile void main() although practically, it does a return 0; on encountering a closing brace.
6 Comments
Konrad Rudolph
gcc -pedantic, however, will reject it. And not using -pedantic is just messed up.
Jed
If you rely on implementation-defined behavior, then your program is not standards-conforming. Your compiler may accept it, but it's not valid C99, just foo-C99.
Niraj Raut
@Konrad Rudolph Hey, if we are not using
gcc -pedantic, does that mean we are not using the standard C? Secondly, I would appreciate it if you tell me where it is written.Niraj Raut
@Jed Hey, if we are not using
gcc -pedantic, does that mean we are not using the standard C? Secondly, I would appreciate it if you tell me where it is written.Konrad Rudolph
@NirajRaut No, on the contrary. I always use at least
-pedantic, or -pedantic-errors. There’s absolutely no reason to use an incorrect return type, it’s just sloppy (but note that free-standing C implementations have different entry point functions!). |
If you're going by the spec, then you should always declare main returning an int.
In reality, though, most compilers will let you get away with either one, so the real difference is if you want / need to return a value to the shell.
8 Comments
Trent
You should always try to do things "by the spec" unless there is a compelling reason not to. Granted, a lot of implementations allow void main, and other extensions. This does not mean you should rely on implementation specific extensions. In embedded applications, with no shell, void main is ok.
Electrons_Ahoy
I'm going to go ahead and agree with all of that. For a while, I got into the habit of using void vs int as a kind of pesudo-comment about whether I was expecting to return a value, but now I just always use int.
Tom
Why is there value in doing the wrong thing (which happens to work in some cases), when the right thing is more work?
Electrons_Ahoy
@Tom: because... the right thing was more work? I'm not sure that sentence parses correctly.
Tom
@Ahoy - I missed one crucial word there... meant to say "...when the right thing is no more work"
|