The article is about the C/C++ language, not about disassembled Windows code. How things are done in Windows may be interesting to know, but not relevant to a C/C++ debate.

First, for your convenience I’ll explain some terms used in both standards:

Hosted environment = programming with an operating system (Windows, Linux, Unix, RTOS etc)
Freestanding environment = programming without an operating system, or programming the operating system itself.

We then have 4 cases:

C in a hosted environment
C in a freestanding environment
C++ in a hosted environment
C++ in a freestanding environment

The C++ standard chapter 3.6.1:

“Main function

A program shall contain a global function called main, which is the designated start of the program. It is implementation-defined whether a program in a freestanding environment is required to define a main function.” /–/

“An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation-defined. All implementations shall allow both of the following definitions of main:

int main() { /* … */ }
and
int main(int argc, char* argv[]) { /* … */ } ”

The C standard:

“5.1.2.1 Freestanding environment

In a freestanding environment (in which C program execution may take place without any benefit of an operating system), the name and type of the function called at program startup are implementation-defined.”

/–/

“5.1.2.2 Hosted environment” /–/

“The function called at program startup is named main. The implementation declares no prototype for this function. It shall be defined with a return type of int and with no parameters:

int main(void) { /* … */ }

or with two parameters (referred to here as argc and argv, though any names may be used, as they are local to the function in which they are declared):

int main(int argc, char *argv[]) { /* … */ }

or equivalent; or in some other implementation-defined manner.”

The above is the absolute truth. You can’t argue with the standard. You can however misinterpret it. In the C standard they end the statement with “or in some implementation-defined manner.”. This refers to the -arguments- of main, not the return type. I believe this was clearified in some errata, though I can’t cite it.

The C++ standard clearly states that:
In a freestanding environment, you don’t need to declare main(), but if you do, it must return int. Now this doesn’t make any sense as there is no underlaying OS to return the value to, yet the standard says so, so we must obey. In freestanding environments you never end the program, so the calling convention of main() isn’t important. In a hosted environment, main() always returns int without exceptions.

The C standard states that:
In a freestanding environment, main() may return any type.
In a hosted environment, main() shall only return int.

In a hosted environment, the following is therefore not allowed in C/C++:

main()
void main()

nor are further variants like WinMain() legal C/C++. This has always been the case, the definition of main() has not been changed in any standard since the first ANSI/ISO C released in 1990. Early “K&R C” might have allowed all kind of crazy stuff, but it was not standardized so it doesn’t matter.

This means that main() and void main() will not compile on a C/C++ compiler made for hosted environments. There will be no runtime crashes, because the code will not even compile. If it compiles, the compiler does not follow ISO C/C++, ie it is not a C/C++ compiler but something else. If you run your C/C++ program on a “something else compiler”, yes then unexpected things are bound to happen.

This also means that most Microsoft compilers aren’t C/C++ compilers. Early Borland compilers are not C/C++ compilers. And so on.

try the following in a windows cmd shell
xcopy
echo %ERRORLEVEL%

xcopy c:\autoexec.bat c:\autoexec.tmp
echo %ERRORLEVEL%

see how the first echo prints 4, and the second one 0. Even windows programs return 0 for successful completion, and this behaviour was taken from Unix, and still holds true today. Windows entry point WinMain, is declared as int WinMain().