In C++, is it mandatory to include the return 0; inside the main function?

How much truth is there in the above statement?

Looking at the C++14 draft , in section 3.6.1 we find the following:

5 A returnstatement in main has the effect of leaving the main function (destroying any objects with automatic storage duration) and calling std::exitwith the returnvalue as the argument. If control reaches the end of main without encountering a return statement, the effect is that of executing

return 0;

Which comes to say the following:

The statement returncauses execution to abandon the main function (objects that go out of scope will be disposed of). In addition, it will be called std::exitwith the value used in it returnas an argument. If the main function ends without a statement return, the statement will be executed:

return 0;

So the answer is NO , it is not mandatory to include the statement returnin the main function .

Yes, it will be mandatory to add this instruction when the application needs to return different values ​​depending on the execution result (for example, to indicate errors).

It would be different if the main declared it as void main(), which is not standard, but at least it is valid in Visual Studio, for example, and there I would see the need to include some kind of return.

If we read section 2 of the aforementioned section (3.6.1):

2 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.

Which basically means that the main function must return a typeint . Of course, for compatibility reasons, there are compilers that swallow with void... but be careful with this because nothing guarantees that the next version of the compiler will accept both that and many other licenses ... you may find yourself in the situation of having to edit dozens of lines of code just to have the program recompile.

how valid it is to use another type of return, such as return EXIT_SUCCESS;, which can be found in one of Luis Joyanes' C++ books.

EXIT_SUCCESSis not a type but is a constant:

#define EXIT_SUCCESS 0

And it's available for both C and C++ via the stdlib.hor cstdlib.

Therefore, EXIT_SUCCESSit is, in your case, equivalent to putting return 0;.

So why use EXIT_SUCCESSif you write more?

Well, keep in mind that both C and C++ have not been designed for a specific architecture... if you find yourself with an Operating System in which an application must return a value other than 0 when it finishes correctly, the macro will adapt without problems while he 0will have to modify it by hand.

I have seen [...] that in C++ it is not necessary to include the statement return 0;in the function mainsince the compiler is able to include the statement on its own. How much truth is there in the above statement?

True, with nuances.

1. It is necessary to return a value in functions that return values ​​or undefined behavior will be incurred ... except in the case ofmain , whose behavior is defined.
2. The compiler will not include any instructions return except in the case ofmain , but it does so to follow the standard, not because it is a free choice of the compiler.

In the C++ standard the relevant text on the first point is (translation and emphasis mine):

9.6.3.2 The instruction return.

The expression-or-list-in-braces of a statement returnis called the operand. A statement returnwith no operand should be used only in functions whose type is void constant or volatile , a constructor or a destructor. An instruction returnwith any other operand must be used only in a function whose return type is not void constant or volatile ; reaching the end of a constructor, destructor, or function with a constant or volatile return type is equivalent to a statement with no operand. In any other case, reaching the end of a function other than results in undefined behaviorvoid returnmain .

The relevant text on the second point is (translation and emphasis mine):

6.6.1.5

A statement returnin mainhas the effect of abandoning the function main(destroying any objects with automatic storage duration) and calling std::exitwith the value of the statement returnas an argument. If control leaves the declaration of main, the effect is equivalent to calling the statement returnwith operand0 .

Conclusion.

While it is true that a C++ compiler following the standard behaves in a defined way on functions mainwithout a statement return, I (personally) object to it for the following reasons:

• Denotes intent : Explicitly writing the return statement shows the programmer's intent; if it is allowed to do so automatically, the question remains as to whether it is an accidental or intentional omission ¹ .
• Homogenize the code : It is disturbing to follow certain and strict rules for all the functions of the code except for one. If the function also mainhad other explicit returns, it would be even more disturbing to rely on one returnimplicit while the others have not been ¹ .
• It follows the principle of least surprise : If a function has a return, the surprising thing would be if it returned nothing (at least in a visibly explicit way).

1. A comment could be added at the end of mainto show that intent:

   int main() {
       try {
           run();
       } catch (const std::exception &) {
           return 1;
       }
       /* devolvemos 0 de manera automatica segun se establece
          en el punto 6.6.1.5 del estandar del lenguaje. */
   }
   

   But it's much easier to just write the returnappropriate statement!

Explaining this topic of the statement " return 0; "; What this does is terminate a function and return control to where the function was called. For example: In the case of a simple C++ program that writes "Hello World"; what this instruction does is end " main " and return control to our machine's operating system; the value 0 tells the operating system that the program has finished successfully. According to the latest version of C++; this return 0 can be omitted and the program will work normally!

I understand the arguments and good programming practices. But going out of convention you could return a 99 and it would only make sense to you, manipulating the main from some console and accessing that return value.