Why would you recursively call main?

Question

I read in C you can recursively call main, but why would you do it?

Answer 1

There isn't a good reason to do it, and it is almost always a bad idea. It just isn't forbidden.

Everything that can be done by calling main recursively can also be done some other, less obscure way, for example by defining a well-named function that is called immediately after entering main and calling that function recursively.

It is allowed in C because it was not explicitly forbidden - as main is just a function, that would require an explicit rule. On the contrary, some additional support for it has been added in the standard over the years, as discussed in answers to this related question. Adding such a rule forbidding it now would be a breaking change and is therefore hardly feasible in practice, and arguably also a waste of effort, as this is rarely a problem.

Answer 2

At first glance, I wouldn't say it is a "bad" idea. It's more like a weird idea. main is just a normal function like everything else. For example, a program that prints the arguments given in reverse:

#include <stdio.h>
int main( int argc, char *argv[] ) {
   if( argc <= 1 ) return 0;
   printf( "%s\n", argv[argc - 1] );
   return main( argc - 1, argv );
}

That being said, more recent C++ standards state that calling main is forbidden. This isn't C++, but that should still be held relevant.

Why should it be forbidden? There could be a number of reasons, despite common compiler implementations not caring about that rule and it working anyway. What speculation comes to mind for me is that that main can actually be implemented as a special entry point, some kind of jump in the assembly that will mangle your stack if you try and call it again. Basically, not a good idea, at least for future-proof code.

While examples for this behavior may be pretty much limited to small academic curiosities, I would pose a certain maintenance issue as the primary reason to avoid it:

• It isn't recommended,
• it is forbidden in a closely related standard, and
• that means it might not work in the future.