Looking online, the only answer seems to be "because void main is wrong", with no explanation of why it's wrong. Does something about a program not work, or function differently if void main is used?
The only reason I, at this moment, can think of to use int rather than void is because some compilers might not accept void main, but if yours does, then it's really a !issue.
It's wrong because the C standard says it's wrong. There is absolutely no reason to break portability for an issue like this IMO.
All problems in computer science can be solved by another level of indirection,
except for the problem of too many layers of indirection.
– David J. Wheeler
Not conforming to a standard wouldn't make it wrong, just not-conforming. If it caused some erroneous functioning, I think that would make it wrong.Originally Posted by SirPrattlepod
>> FAQ > main() / void main() / int main() / int main(void) / int main(int argc, char *argv[]) - Cprogramming.com
Thanks.
I also find the 3 responses starting at #6, here, to be pretty good justification for choice of practice:
Int Main(void) Vs Void Main - C And C++ | Dream.In.Code
One issue is the effect on batch files or scripts. The value returned by main is treated as a program's "exit code". Depending on the operating system, batch files and/or scripts can make use of program exit codes to conditionally change which steps of the batch file or script are used. Typically it's for error handling, but for some combinations of programs and batch files / scripts, the exit codes are used for control. On some operating systems, the batch or script process will be aborted if the exit code is "out of range".
For the "why", my guess is along the same lines as rcgldr's explanation.
Technically, not conforming in this case results in undefined behaviour. One characteristic of undefined behaviour is that it may appear to work, but it might not after compiling again with say, some change in compile options, or when the compiler is upgraded, etc. Hence, it is wrong.
However, if a compiler documents the behaviour, then it working would be guaranteed, so long as you recognise that you are coding to a particular implementation. In this case, there is no reason to code to a particular implementation. Where it might make sense for you to code to a particular implementation is say, when an implementation provides for a main function with more arguments, e.g., a third argument for environment variables.
Look up a C++ Reference and learn How To Ask Questions The Smart Way
I thought even void functions technically had a return status.
A function that is void returns normally, but what you can't depend on is the caller's stack having room for a return value (because the function returns to the caller), or there being a return value that makes sense on the stack. All sorts of weirdness can happen if you intended for there to be a return value and you use a function with a void return type that way.
And a stack frame is not necessarily implemented in such a way that it depends on secret values ever being used for void return types.
In many cases, such as Intel X86, ARM, 68000 series, ... the return value is returned via a register. In the case of a void function, the return value could be whatever was left over from previous operation. The behavior after that depends on what the operating system, and or any currently running batch file or script does with program exit codes.
Only if you're in a situation where conformance against that standard is not required.
The purpose of a standard is to be a yardstick against which correctness is assessed. If conformance is an essential or contracted requirement, then non-conformance is a breach of requirement. That is usually considered to be wrong in various ways: an essential requirement not met, a breach of contract, ethically, etc etc.
In a C forum, it is reasonable to expect that conformance with a C standard would be an expectation, and that non-conformance would be considered wrong.
void main() technically invokes undefined behaviour according to the standard. Anything is allowed to happen, including erroneous behaviour.
Code using void main() will typically result in some form of erroneous behaviour if compiled with a compiler that does not support void main(). The three types of real-world consequences include a compilation error (compiler reports an error), a linker error (the executable cannot be built), or a runtime error (the program can be built, but does not run as intended). All of those are reasonably considered erroneous behaviour.
The reason the standard specifies int main() is to allow the possibility of returning data to the environment in which the program is run (e.g. a shell script that invokes the program). void main() would prevent returning any information to the environment. int main() allows a value to be returned, but neither forces the program to return a value nor forces the environment to interpret that value.
the relevant section of the standard is 3.6.1.2:
Why?
Because the standard says so.
What can this strange device be?
When I touch it, it gives forth a sound
It's got wires that vibrate and give music
What can this thing be that I found?
I thought it was actually so you could run a program and go echo $? and have the output be useful. C was first developed on Unix/Linux, right?
more likely C was first developed to (re) write Unix
C (programming language) - Wikipedia, the free encyclopedia
All problems in computer science can be solved by another level of indirection,
except for the problem of too many layers of indirection.
– David J. Wheeler
I see. Then yes, it would be useful to have a program return a number because it could easily be interpreted by the OS. It'd be C talking to C, if Unix was written in it. You could do a lot with that and it'd give the user a lot of power to run a program, ensure it ran correctly and if it didn't, what did it return as that could indicate failures across the map. If it didn't, you could pipe that into different programs,etc.
Returning void would remove a lot of that power and it'd limit a lot of things.
Also, go Unix!!!! Unix best OS 2013!
But remember the only things that you are guaranteed to be able to return from main() are 0, EXIT_SUCCESS, EXIT_FAILURE, anything else is implementation defined. For example on Linux the only values you can return from main() are values that will fit in an unsigned char value (0 to 255).
Jim
