Brackets around 0 in "return (0);" statement in 'main' function - what are they for?

Question

Usually auto-generated c++ "main" function has at the end

return (0);

or

return (EXIT_SUCCESS);

But why there are parentheses in above statements? Is it related to C language or something?

// EDIT

I know this is correct, but someone put these brackets for a reason. What's the reason?!

Answer 1

They are not required (even in c). I think some people use them to make 'return' look more like a function call, thinking it is more consistent.

Edit: It's likely the generator does this for it's own reasons. It may be safer or easier for it to work this way.

Answer 2

But why there are parentheses in above statements? Is it related to C language or something?

No. As far as I can tell, C has never required parentheses for return statements. This appears to have been the case even before the first ANSI C standard.

This is actually a very interesting question, however, as I've seen that style prevalent among certain C programmers.

I think the most likely guess as to why this style came about is because all other branching statements (for, while, if, switch) require parentheses around expressions. People might have been unaware that they could omit the parentheses for return statements or were aware of this but wanted to achieve a more uniform look to their code.

The ternary ?: operator is sort of an exception as it is an operator and doesn't require parentheses around the conditional expression, yet people often write parentheses there as well regardless of whether it's needed. Some might find it serves to 'group' an expression into a single unit visually.

My second best guess is that this style was influenced by other languages popular at the time. However, popular, procedural alternatives at the time like Pascal did not require that syntax either (Pascal did not even have return values in the C sense but only output parameters) so if this is the case, I'm not aware of any particularly language from which this style originated.

[Subjective] I prefer styles that require the least amount of superfluous decoration to the code whether it comes to naming conventions or how to format it or whether to use additional parentheses where unnecessary. I find that any such decoration tends to be a matter of unique personal preference and falling in love with one way of decorating code just means that someday you'll have to deal with a completely different way (unless you work strictly alone, in which case I envy you). [/Subjective]

Answer 3

This is actually a requirement for BSD kernel source file style.

man 9 style says:

Space after keywords (if, while, for, return, switch).

and

Values in return statements should be enclosed in parentheses.

Answer 4

Things changes with the use of decltype(auto) in c++14 to deduce return type. If parentheses are used then returned type is deduced to be a reference:

decltype(auto) foo1() {
   int n;
   return (n); // parentheses causes return type to be int&
}

decltype(auto) foo2() {
   int n;
   return n; // no parentheses causes return type to be int
}

template<typename T> struct TD;

int main()
{
  // main.cpp:19:22: error: aggregate 'TD<int&()> f1' has incomplete type and cannot be defined TD<decltype(foo1)> f1;
  TD<decltype(foo1)> f1;

  // main.cpp:20:22: error: aggregate 'TD<int()> f2' has incomplete type and cannot be defined TD<decltype(foo2)> f2;
  TD<decltype(foo2)> f2;
}

Answer 5

As any valid expression can be passed to return, those brackets can be added if desired. It is like doing this:

int i = (0);

You can nest an expression in as many brackets as you like:

return (((((0)))));

Answer 6

There's a dumb reason - to make return look more like a function call.

There's a smarter reason - if the code is generated, code generators often "play it safe" by putting parentheses around expressions just so they never have to be concerned about the precedence leaking out.

Answer 7

Those are not required. Maybe they come from the tendency to prefer more brackets to fewer brackets when writing macros.

Since you mention auto-generated code it might happen that the code used for generating macros was written by reusing code for generating macros or by a person who thought that more brackets won't hurt, but fewer brackets can be fatal.

Answer 8

Just my silly speculation:

#define RETURN(val) { if (val) printf("Main Exit With Error %d\n", val); return val; }

int main(argc, argv)
{
  ...
  RETURN (E_FILENOTFOUND);
}

Answer 9

One reason I can see for this:

return (ERROR_SUCCESS);

is that it's expressing the concept that ERROR_SUCCESS is opaque. We all know it's 0L, but we shouldn't have to.

That's a fairly weak reason.

Another is that it's aesthetically pleasing to use parentheses for consistency, another weak reason.

So in other words, I don't use it myself, but wouldn't flip out if someone else did. :)