Can main function call itself in C++?
TLDR: Calling main results in undefined behavior.
There seems to be confusion about the terminology used in the standard, and the implications that has for the programmer and compiler.
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:
The 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."
I hope this clears things up.
It's like being a drug-dealer. Pretty illegal, but compiles and even works out good for some time...
Calling main in C++ is illegal (§3.6.1.3):
The function main shall not be used within a program.
Your compiler is allowing illegal behavior.
It loops forever because, well, main calls main, who calls main, who calls main, and so on.
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();
}