Forgetting to write a return in a function returning a value

[hectorchu]

Why doesn't my compiler (g++) flag something like this as an error:

int main()
{
}

?

 

[Tim Love]

Why doesn't my compiler (g++) flag something like this as an error:

int main()
{
}

Because main's special. Try the same thing in another function.

 

[G Kettleborough]

Why doesn't my compiler (g++) flag something like this as an error:

int main()
{
}

?

Because it's not an error, in fact is is absolutely correct. In C++ the
void argument is implicit for any function. For main, return 0 is
implicit if you don't write an explicit return. Also for main the only
two proper ways to write it are:

int main()
{
}

and

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

int main(void) is wrong.

 

[hectorchu]

Because main's special. Try the same thing in another function.

Following your suggestion, I tried the following:

int f()
{
}

int main()
{
return f();
}

This compiles okay too. So I don't think what I'm describing is
specific to main.

 

[George Kettleborough]

No, it isn't. It's ugly, but it's not wrong.

V

Well the standard defines only those two. Or do you mean that int
main(void) is simply the explicit version of of int main() so equivalent?

 

[peter koch]

Why doesn't my compiler (g++) flag something like this as an error:

int main()
{

}

As others have told you, main is special. It is not required to have
an explicit return, and if it returns via the end, this corresponds to
return 0. Don't ask me why that silly rule was implemented.

Now, take another function:

int foo() {}

Surprisingly this function is also ok: you just can't call it:
execution of f will lead to undefined behaviour. Why is this so?
Because it can be very difficult if not impossible to determine if a
function returns anything or not. Let's expand foo a little:

external void report_error(char const*);
int foo()
{
if (rand() < 10)
return 777;
report_error("Illegal random result in foo");
}

Now, this function might or not return, depending on report_error.
report_error might call exit, it might throw en exception or it might
just log the error and return. It might even do one of the three
things depending on some external state.

It is only when report_error returns, we get undefined behaviour.
Now, you could burden the programmer and require him to write a dummy
return-statement, but this might have its own problems: it adds dead
code to the function, and this can be a burden in some environments,
especially if the stuff returned is something more complicated than a
simple int and it might make code somewhat obfuscated (imagine the
call being replaced by a throw).

That said - if you've followed me so far - every decent compiler will
(or can be made to) warn about the missing return statement, and most
compilers also have the ability to treat certain warnings as errors,
so basically it is a question of setting your environment up in a way
that satisfies your requirements.

/Peter

 

[Ian Collins]

Following your suggestion, I tried the following:

int f()
{
}

int main()
{
return f();
}

This compiles okay too. So I don't think what I'm describing is
specific to main.

Invoke it in conforming mode and you will.

 

[Andrey Tarasevich]

Why doesn't my compiler (g++) flag something like this as an error:

int main()
{
}

?

Because in C++ it is not an error, in a sense that it is not ill-formed.
(And no, in that regard 'main' is no different from any other
function). C++ language specification does not require compilers to
detect and diagnose execution paths that flow off the end of a
value-returning function without an explicit 'return' statement. In
general case, flowing off in such a context produces undefined behavior
(not in 'main' though, which is where is does indeed get special), but
the program still remains well-formed. In other words, it is your
responsibility to remember to include an explicit 'return' statement
into every possible control path of a value-returning function. Some
compilers might help you to detect the paths where you forgot to provide
a 'return', but in any case they are not required to do so.

 

[James Kanze]

Invoke it in conforming mode and you will.

Not necessarily; it's undefined behavior. And compilers that
warn when in fact you can't reach the end can be very irritating
as well.