Should return 0; be avoided in main()?

Question

I know that the current C++ standard special cases main so that falling off the end has the same effect as return 0; rather than undefined behavior.

I was recently surprised to see an example at codereview where the responses not only pointed out that including the final return 0; is optional, but actually went so far as to remove it from the original code.

Thus prompts my question — is it really considered bad style to make the return 0; explicit at the end of main? What is the rationale for or against?

Answer 1

I'll take a wild stab in the dark here and say that people fall into two camps:

• those who remove the line think it is redundant and all such code should be removed for brevity

• those who add the line think it makes the return value clear and unambiguous to lesser coders.

Personally, I would tend to always write a meaningful return statement in main in my production code (if only because my production mains tend to also contain code paths that end up returning something other than 0, generally in exception handlers), although I wouldn't bother for a trivial main that never returns anything else; for example, I don't think I've ever done so in, say, a Coliru post for a Stack Overflow demonstration.

Some would say that it's absurd to alter a codebase to flip between these two states, that the arguments are both very weak in the grand scheme of things, and that such a personal choice is not worth risking the introduction of bugs.

But I'd say this depends almost entirely on what your environment is like. If you're halfway through a release cycle, of course you're going to make code maintenance improvements and style adjustments: this is the best time to avoid accruing technical debt, and you absolutely want to do that. But if you're planning to make this change directly on a production server, or in version control one week before that big release, you're out of your mind.

(Hopefully your policies prevent such madness anyway. Code freeze, yes? No changes to production, right?)

So, although it goes without saying that the underlying choice is highly subjective, we can quantify the risk/benefit of enforcing such a choice after-the-fact.

But never mind real life, what about on Code Review? Well, I have no idea; you'd have to ask them. Personally, on those specific examples, I probably would have removed it too, albeit with the written caveat that this were purely a style choice. Whether purely style changes are appropriate on Code Review is a question for Code Review Meta.

Answer 2

From C++, 3.6.1 Main Function

(3.6.1/5) An implementation shall not predefine the main function. This function shall not be overloaded. 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[]) { /* ... */ }

So in C++, two prominent signatures for main function are : int main() and int main(int argc, char** argv)

Further in C++, 3.6.1 Main function

(3.6.1/5) A return statement in main has the effect of leaving the main function (destroying any objects with automatic storage duration) and calling exit with the return value as the argument. If control reaches the end of main without encountering a return statement, the effect is that of executing return 0;

So, although the signature suggest that function should return some integer, it is not necessary to return 0. By default, C++ considers return value to be 0.

Advantages:
- Treating main as normal function and following similar C++ coding convention
- return 0 explicitly specify normal return value, in other cases we can return non-zero value

Although, all these points are matter of coding convention. It is still choice of programmer!