By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
432,441 Members | 996 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 432,441 IT Pros & Developers. It's quick & easy.

Forgetting to write a return in a function returning a value

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

int main()
{
}

?
Nov 4 '08 #1
Share this Question
Share on Google+
12 Replies


P: n/a
he*******@gmail.com writes:
>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.

Nov 4 '08 #2

P: n/a
he*******@gmail.com wrote:
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.

--
George Kettleborough
Nov 4 '08 #3

P: n/a
G Kettleborough wrote:
he*******@gmail.com wrote:
>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.
No, it isn't. It's ugly, but it's not wrong.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Nov 4 '08 #4

P: n/a
On 4 Nov, 10:48, t...@eng.cam.ac.uk (Tim Love) wrote:
hector...@gmail.com writes:
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.
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.
Nov 4 '08 #5

P: n/a
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Jensen Somers wrote:
Because in C++ main() is the only function which does not explicitly
needs a return statement [1]. It may also depend on the type of warning
level you specified.
Indeed, it depends. If you had used flag -Wall (in gcc), you would have
got warning for int f().

Pawel Dziepak
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (GNU/Linux)
Comment: Using GnuPG with Fedora - http://enigmail.mozdev.org

iEYEARECAAYFAkkQX5QACgkQPFW+cUiIHNottACeIqONjHogSO IhwP0xxm3SobgI
WPAAni5YA8z2fF6f2aACjBTEREbtQ6bv
=hpct
-----END PGP SIGNATURE-----
Nov 4 '08 #6

P: n/a
he*******@gmail.com wrote:
On 4 Nov, 10:48, t...@eng.cam.ac.uk (Tim Love) wrote:
>hector...@gmail.com writes:
>>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.

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.
That's compiler-specifc. Comeau complains:
warning: missing return statement at end of non-void function "f"
This
int f() {return 0;}

int main() {}

OTOH, compiles without warning.

Schobi
Nov 4 '08 #7

P: n/a
Victor Bazarov wrote:
>
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?
--
George Kettleborough
Nov 4 '08 #8

P: n/a
On 4 Nov., 11:39, hector...@gmail.com wrote:
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
Nov 4 '08 #9

P: n/a
he*******@gmail.com wrote:
On 4 Nov, 10:48, t...@eng.cam.ac.uk (Tim Love) wrote:
>hector...@gmail.com writes:
>>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.

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.

--
Ian Collins
Nov 4 '08 #10

P: n/a
George Kettleborough wrote:
Victor Bazarov wrote:
>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?
Yes, I meant that the forms '()' and '(void)' are equivalent. See
8.3.5/2. In my [purist's] view, the '(void)' is an abomination, but
it's a hold-over from C, so it's legal. Perhaps you meant something
other than "ill-formed" when you wrote "wrong", then I apologise.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Nov 4 '08 #11

P: n/a
he*******@gmail.com wrote:
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.

--
Best regards,
Andrey Tarasevich
Nov 4 '08 #12

P: n/a
On Nov 4, 7:18 pm, Ian Collins <ian-n...@hotmail.comwrote:
hector...@gmail.com wrote:
On 4 Nov, 10:48, t...@eng.cam.ac.uk (Tim Love) wrote:
hector...@gmail.com writes:
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.
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.
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.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Nov 5 '08 #13

This discussion thread is closed

Replies have been disabled for this discussion.