Can main() call itself??????

One of the most famous interview Question:

One of the most famous interview Question:

int main () {
return main();
}  

What would be the output of above code.??????

When I tested it practically, I found that code actually compiles but it runs forever.
Then I searched over internet and come to the following solution.

Firstly, the standard alone determines everything about the C++ language. If your particular version of a particular compiler allows some particular action, that has no bearing on whether or not that action is legal. For the remainder of the post, I’m referring to the ISO03 standard.

So to quote once again, the standard says in §3.6.1.3:

“function main shall not be used within a program.”

Additionally, §3.2 defines “used” as:
 
“An object or non-overloaded function is used if its name appears in a potentially-evaluated expression.”

This means that once the program begins executing, main should never be entered again. That means programmers cannot call main, that means the compiler cannot insert another call to main (why it would, who knows), you cannot take the address of main and call that, etc. You cannot even have the potential of calling main.

The only call to main should be by the run-time library the program is running on; all other calls invoke undefined behavior. (Which means anything could happen!)

Now onto compiler behavior:

A diagnosable rule is defined as (§1.4.1):

The set of diagnosable rules consists of all syntactic and semantic rules in this International Standard except for those rules containing an explicit notation that “no diagnostic is required” or which are described as resulting in “undefined behavior.”

In our case, §3.6.1.3 defines a diagnosable rule. Here’s what compilers should do according to §1.4.2:

— If a program contains no violations of the rules in this International Standard, a conforming implementation shall, within its resource limits, accept and correctly execute3) that program.
— If a program contains a violation of any diagnosable rule, a conforming implementation shall issue at least one diagnostic message, except that
— If a program contains a violation of a rule for which no diagnostic is required, this International Standard places no requirement on implementations with respect to that program.

So compilers are not required to enforce rules. All compilers have to do is take well-formed programs (§1.3.14) and turn them into an executable program. A compiler is free to warn, error, etc. however it likes, as long as it does not conflict with the language. It is required to display a message in our particular case, according to the second clause.

For this particular problem, on gcc the -pedantic option will warn about the illegality of calling main within the program. Visual Studio will not warn about calling main, but on any warning level (greater than 0) it will warn about the recursive nature of the program.

What does all this mean in terms of the answers you should expect? It means it’s completely meaningless to try and define with certainty what the code snippet posted will do. Calling main results in undefined behavior, and trying to define undefined behavior is obviously a lost cause. The only honest answer anyone can give to “what happens when I call main?” is “Anything.”

Of course if you really want call your main function recursively, and sometimes there are good reasons, you should just do this

int mymain() { 
return mymain();

 int main() {
return mymain();
}


I hope this clears things up.

Share
loading...

Leave a Reply

Your email address will not be published. Required fields are marked *