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]

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.

[G Kettleborough]

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

[Victor Bazarov]

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

[hectorchu]

On 4 Nov, 10:48, [e-mail] .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.

[Pawel Dziepak]

-----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

iEYEARECAAYFAkk QX5QACgkQPFW+cU iIHNottACeIqONj HogSOIhwP0xxm3S obgI
WPAAni5YA8z2fF6 f2aACjBTEREbtQ6 bv
=hpct
-----END PGP SIGNATURE-----

[Hendrik Schober]

he*******@gmail .com wrote:

On 4 Nov, 10:48, [e-mail] .uk (Tim Love) wrote:

>hector...@gmai l.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

[George Kettleborough]

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

[peter koch]

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(ch ar const*);
int foo()
{
if (rand() < 10)
return 777;
report_error("I llegal 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]

he*******@gmail .com wrote:

On 4 Nov, 10:48, [e-mail] .uk (Tim Love) wrote:

>hector...@gmai l.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