C++ declare 'main' as a reference to function?

Question

What if I define main as a reference to function?

#include<iostream>
#include<cstring>

using namespace std;

int main1()
{
    cout << "Hello World from main1 function!" << endl;
    return 0;
}

int (&main)() = main1;

What will happen? I tested in an online compiler with error "Segmentation fault":

here

And under VC++ 2013 it will create a program crashing at run-time!

A code calling the data of the function pointer as a code will be compiled which will immediately crash on launch.

I would also like an ISO C++ standard quote about this.

The concept will be useful if you want to define either of 2 entry-points depending on some macro like this:

int main1();

int main2();

#ifdef _0_ENTRY
int (&main)() = main1;
#else
int (&main)() = main2;
#endif

Answer 1

That's not a conformant C++ program. C++ requires that (section 3.6.1)

A program shall contain a global function called main

Your program contains a global not-a-function called main, which introduces a name conflict with the main function that is required.

---

One justification for this would be it allows the hosted environment to, during program startup, make a function call to main. It is not equivalent to the source string main(args) which could be a function call, a function pointer dereference, use of operator() on a function object, or construction of an instance of a type main. Nope, main must be a function.

One additional thing to note is that the C++ Standard never says what the type of main actually is, and prevents you from observing it. So implementations can (and do!) rewrite the signature, for example adding any of int argc, char** argv, char** envp that you have omitted. Clearly it couldn't know to do this for your main1 and main2.

Answer 2

This would be useful if you want to define either of 2 entry-points depending on some macro

No, not really. You should do this:

int main1();
int main2();

#ifdef _0_ENTRY
   int main() { return main1(); }
#else
   int main() { return main2(); }
#endif

Answer 3

This is soon going to become clearly ill-formed, thanks to the resolution of CWG issue 1886, currently in "tentatively ready" status, which adds, among other things, the following to [basic.start.main]:

A program that declares a variable main at global scope or that declares the name main with C language linkage (in any namespace) is ill-formed.

Answer 4

What will happen in practice is highly dependent on the implementation.

In your case your compiler apparently implements that reference as a "pointer in disguise". In addition to that, the pointer has external linkage. I.e. your program exports an external symbol called main, which is actually associated with memory location in data segment occupied by a pointer. The linker, without looking too much into it, records that memory location as the program's entry point.

Later, trying to use that location as an entry point causes segmentation fault. Firstly, there's no meaningful code at that location. Secondly, a mere attempt to pass control to a location inside a data segment might trigger the "data execution protection" mechanisms of your platform.

By doing this you apparently hoped that the reference will get optimized out, i.e. that main will become just another name for main1. In your case it didn't happen. The reference survived as an independent external object.

Answer 5

Looks like you already answered the question about what happens.

As far as why, in your code main is a reference/pointer to a function. That is different than a function. And I would expect a segment fault if the code is calling a pointer instead of a function.