What will happen if main called in side main function?

[Ravi]

void main()
{
main();
}

int main()
{
main();
}

[Skarmander]

Keith Thompson wrote:

Skarmander <in*****@dontma ilme.com> writes:
[...]

GCC with -std=c99 will not issue a warning, because in C99 it's legal
to omit the return statement from main() (and *only* main()), in which
case a return value of 0 is implied.

I don't think I've yet read why this was considered a good idea; maybe
to retroactively fix all the broken code that invoked undefined
behavior.
Omitting the return statement in main() never invoked undefined
behavior (unless a recursive call to main() attempts to use the
result). At worst, it merely returns an unspecified status to the
calling environment, and the behavior of the calling environment is
outside the scope of the C standard.

Yes, true. Although some calling environments will get quite upset if you
don't return a decent value from main(), the hissy fit they throw is not
undefined behavior.

I'm confusing this with declaring main as returning void, which is a lot worse.
I think part of the motivation for the change is that made some of the
examples in K&R retroactively valid.

That's... interesting. I suppose it really doesn't matter much, as it's a
minor thing. But still, a peculiar addition.

S.

[Richard Tobin]

In article <11************ **********@i40g 2000cwc.googleg roups.com>,
sw***********@g mail.com <sw***********@ gmail.com> wrote:

> int main()
> {
> main();
> }

Also this should cause a compiler
warning about no return statement in a non void function, at least on
any compiler I have ever used.

Since the recursive call to main() never returns, the end of the
function cannot be reached, so a return statement would be
superfluous. Indeed, a sufficiently good compiler would warn if
you did have one!

-- Richard

[Keith Thompson]

ri*****@cogsci. ed.ac.uk (Richard Tobin) writes:

In article <11************ **********@i40g 2000cwc.googleg roups.com>,
sw***********@g mail.com <sw***********@ gmail.com> wrote:

> int main()
> {
> main();
> }

Also this should cause a compiler
warning about no return statement in a non void function, at least on
any compiler I have ever used.

Since the recursive call to main() never returns, the end of the
function cannot be reached, so a return statement would be
superfluous. Indeed, a sufficiently good compiler would warn if
you did have one!

A sufficiently good compiler would translate the program to a single
instruction that does the equivalent of a stack overflow.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Skarmander]

Keith Thompson wrote:

ri*****@cogsci. ed.ac.uk (Richard Tobin) writes:

In article <11************ **********@i40g 2000cwc.googleg roups.com>,
sw***********@g mail.com <sw***********@ gmail.com> wrote:

> int main()
> {
> main();
> }
Also this should cause a compiler
warning about no return statement in a non void function, at least on
any compiler I have ever used.

Since the recursive call to main() never returns, the end of the
function cannot be reached, so a return statement would be
superfluous. Indeed, a sufficiently good compiler would warn if
you did have one!

A sufficiently good compiler would translate the program to a single
instruction that does the equivalent of a stack overflow.

Actually, I would be impressed if the compiler turned it into a self-jump
instead. Optimizing tail recursion is not very hard, but it generally
doesn't pay off in imperative languages, so you don't see many C compilers
doing it.

Of course, an even more efficient compiler would use the equivalent of HLT,
to save processor cycles.

S.

[Jordan Abel]

On 2006-03-31, Skarmander <in*****@dontma ilme.com> wrote:

Keith Thompson wrote:

ri*****@cogsci. ed.ac.uk (Richard Tobin) writes:

In article <11************ **********@i40g 2000cwc.googleg roups.com>,
sw***********@g mail.com <sw***********@ gmail.com> wrote:

>> int main()
>> {
>> main();
>> }
Also this should cause a compiler
warning about no return statement in a non void function, at least on
any compiler I have ever used.
Since the recursive call to main() never returns, the end of the
function cannot be reached, so a return statement would be
superfluous. Indeed, a sufficiently good compiler would warn if
you did have one!

A sufficiently good compiler would translate the program to a single
instruction that does the equivalent of a stack overflow.

Actually, I would be impressed if the compiler turned it into a self-jump
instead. Optimizing tail recursion is not very hard, but it generally
doesn't pay off in imperative languages, so you don't see many C compilers
doing it.

Of course, an even more efficient compiler would use the equivalent of
HLT, to save processor cycles.

Or just have it exit after a set time. Would be really impressive on
benchmarks.

[swengineer001]

Richard Tobin wrote:

In article <11************ **********@i40g 2000cwc.googleg roups.com>,
sw***********@g mail.com <sw***********@ gmail.com> wrote:

> int main()
> {
> main();
> }

Also this should cause a compiler
warning about no return statement in a non void function, at least on
any compiler I have ever used.

Since the recursive call to main() never returns, the end of the
function cannot be reached, so a return statement would be
superfluous. Indeed, a sufficiently good compiler would warn if
you did have one!

-- Richard

I can't get a warning out of my compilers for the following:

int main()
{
main();
return 0;
}

However I do get warning for the original one with no return statement.
I would think that in general irt would be very hard for the compiler
to recognize that recursion is going to continue forever.

[Skarmander]

sw***********@g mail.com wrote:

Richard Tobin wrote:

In article <11************ **********@i40g 2000cwc.googleg roups.com>,
sw***********@g mail.com <sw***********@ gmail.com> wrote:

> int main()
> {
> main();
> }
Also this should cause a compiler
warning about no return statement in a non void function, at least on
any compiler I have ever used.

Since the recursive call to main() never returns, the end of the
function cannot be reached, so a return statement would be
superfluous. Indeed, a sufficiently good compiler would warn if
you did have one!

-- Richard

I can't get a warning out of my compilers for the following:

int main()
{
main();
return 0;
}

However I do get warning for the original one with no return statement.
I would think that in general irt would be very hard for the compiler
to recognize that recursion is going to continue forever.

Actually, this isn't just very hard, it's impossible in general.
http://en.wikipedia.org/wiki/Halting_problem

S.

[Kenneth Brody]

Ravi wrote:

But i have read that C can have only one main function, so is this
valid?
Please see the other posts about how to properly reply using Google's
interface.

Here is the code from your original post:
void main()
{
main();
}

int main()
{
main();
}

If you mean to have both of these functions in one file, then this is
not valid. However, this would be true regardless of the name of the
function.

--
+-------------------------+--------------------+-----------------------------+
| Kenneth J. Brody | www.hvcomputer.com | |
| kenbrody/at\spamcop.net | www.fptech.com | #include <std_disclaimer .h> |
+-------------------------+--------------------+-----------------------------+
Don't e-mail me at: <mailto:Th***** ********@gmail. com>