main() function in C

Question

I've been learning C programming in a self-taught fashion for some weeks, and there are some questions that I have concerning the main() function.

All functions must be declared in their function prototype, and later on, in their defintion. Why don't we have to declare the main() function in a prototype first?
Why do we have to use int main() instead of void main()?
What does return 0 exactly do in the main() function? What would happen if I wrote a program ending the main() function with return 1;, for example?

`main()` even has its own [Wikipedia page](http://en.wikipedia.org/wiki/Main_function) — huysentruitw, Aug 26 '13 at 14:38
@user2718426 Heads up, 'round these parts, we like to keep each question to only one question at a time. So your post sounds like three questions. Though you'd find lots of writing about the second already, like http://stackoverflow.com/questions/9356510/int-main-vs-void-main-in-c — Prashant Kumar, Aug 26 '13 at 14:43
You can get the value returned by your program with `$?` on unix systems (must be something else on Windows) : `./myprog && echo $?` — Michael M., Aug 26 '13 at 14:45
@Michael If you use `&&` in that construct, `echo` won't run unless `$?` is zero. — Fred Foo, Aug 26 '13 at 14:55
The funny thing is, on most systems the vast majority of numbers that `main()` can return aren't actually returned properly because the OS only supports a subset (like 0 - 255 or something silly). I usually just restrict myself to 0 and 1, or maybe a few more. — Veltas, Aug 26 '13 at 15:46
Instead of returning 0, from the main, it would be wise, if you use the predefined macro for the same, from `stdlib.h`, which is `return EXIT_SUCCESS;`, since this will expand to a system-dependent integral expression :-) — nIcE cOw, Aug 26 '13 at 16:04

score 24 · Accepted Answer · edited Oct 23 '18 at 18:23

24

A declaration of a function is needed only before a function is used. The definition is itself a declaration, so no prior prototype is required. (Some compilers and other tools may warn if a function is defined without a prior prototype. This is intended as a helpful guideline, not a rule of the C language.)
Because the C standard says so. Operating systems pass the return value to the calling program (usually the shell). Some compilers will accept void main, but this is a non-standard extension (it usually means "always return zero to the OS").
By convention, a non-zero return value signals that an error occurred. Shell scripts and other programs can use this to find out if your program terminated successfully.

edited Oct 23 '18 at 18:23

Eric Postpischil

195,579
13
168
312

answered Aug 26 '13 at 14:43

Fred Foo

355,277
75
744
836

There is no rule in the C standard (versions from 1999 to 2018 at least) that says `main` must not be called from any other function. Clause 5.1.2.2.3 even includes a reference to “the initial call to the `main` function,” thus acknowledging the possibility of subsequent calls. Nor is there any rule that if any function, `main` or otherwise, must not be called from any other function for some reason, it must not be declared. – Eric Postpischil Oct 23 '18 at 13:29
Possibly the statement in the C standard that “The implementation declares no prototype for this function [`main`]” could cause some confusion, but it just means that the C implementation does not provide a declaration. That is, it is not built into the compiler or any standard headers. It does not mean the program may not declare a prototype for `main`. – Eric Postpischil Oct 23 '18 at 13:30

score 18 · Answer 2 · edited Jan 14 '14 at 17:07

1) All functions must be declared in their function prototype, and later on, in their definition. Why don't we have to declare the main() function in a prototype first?

Not true. Simple example:

void foo(){}  //definition

int main()
{
    foo();
    return 0;
}

Only when one function is called but the definition isn't seen yet, a declaration is required. That will never happen to main since it is the starup of the program.

2) Why do we have to use int main() instead of void main()?

Because the standard says so. (To be more precise, it's true on a hosted environment, which is usually the case)

C99 5.1.2.2.1 Program startup

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.

3) What does return 0 exactly do in the main() function? What would happen if I wrote a program ending the main() function with return 1, for example?

The return value indicates the result of the program. Usually 0 indicates success while other values indicates different kinds of failure.

score 3 · Answer 3 · answered Aug 26 '13 at 15:03

You are not free to chose the return type of main because you did not write the code that calls main. The code calling main already existed before you even thought about learning C. It was written by the folks providing the C runtime startup code, which usually is linked automatically to your executable without you knowing. This code often resides in a file called crt0.o (created from crt0.c or even assembler in crt0.s). It expects to use a return value indicating success (0) or failure (nonzero), plus possibly other information like whether the code was terminated due to a signal and if so, which one. These are bits of Unix history, that I won't repeat here :-)

score 1 · Answer 4 · answered Aug 26 '13 at 14:45

1) Not necessarily; a definition also serves as a declaration. Secondly, there are only a few valid signatures for main anyway, and you normally won't call main within your code unless you're writing an entry for the IOCCC.

2) Short answer: because the language definition says so. Longer answer: this is how your program indicates success or failure to the host environment. An individual implementation is free to support additional signatures for main, but it must document those additional signatures. If your compiler documentation does not list void main() as a legal signature, then you shouldn't use it.

3) By convention (at least on *nix systems where C was first used), a status of 0 indicates success, and a non-zero status indicates ... something other than success. Exactly what value corresponds to what status is up to the implementation.

score 0 · Answer 5 · answered Aug 26 '13 at 14:41

0

1) it is false, you can only create the defintion of a function.

2) we can know if the main() function correctly terminate

3)the same except that in your shell it will be writed 1 instead of 0

answered Aug 26 '13 at 14:41

jambono

398
1
8

zentrunix · Answer 6 · 2013-08-26T15:38:13.937

0

Functions need not necessarily be declared first as a prototype. Such a declaration is needed only if we need to use a function before it is defined.

main has type int by definition.

The meaning of the value returned from main is conventional. The convention generally accepted is that 0 is considered success, and not 0 some kind of failure.

edited Aug 26 '13 at 15:38

answered Aug 26 '13 at 14:48

zentrunix

2,098
12
20

score 0 · Answer 7 · answered Aug 26 '13 at 14:51

1.The main() function is implicitly called by the C library by recognizing the in-built keyword 'main'. So we don't need to declare a prototype for main function .

2.This I am not sure, but I think it depends on the type of editor used . In Turbo C , void main() will be accepted, whereas in dev-cpp main() should return a value.

3.return 0 simply exits the program with exit status 0 , in other words the return value determines the exit status of the main thread.

score 0 · Answer 8 · answered Aug 26 '13 at 15:11

Simply put most essence for all of your questions is traditions and conformance. Toolchains, operating systems, etc know that way that this procedure called main(), must be called out first from the user code space(program)...

Now specifically: 1) Because of the conformance as I said. You do not need to declare because toolchains and operating systems know already about main. Also there are other conformance functions like exit().

2) When the main some time returns then the operating system can have the result back from it. Usually non zero means error. So when U are using scripts or other programs calling out your program e.g. main() function, you can check if it was successful.

3) Return something else than zero means error. But actually you can interpret that value how you want it. But as I said OS can have the result.

Additional info: main() is actually not THE FIRST function (you have written) that will be called out when you start the program. BUT actually operating systems and tool chains facilitate other calls before your main, to setup environment, do the initialization or whatever. But you do not know about that directly when you are writing your code and you do not have to deal with that and think about that at all. In embedded systems there will be usually some very low level functions called to setup the CPU main clock, interrupts, stack, etc. Some of the tool chains like IAR actually can enable you to execute your own code before main is called.

Hope this helped :)

score 0 · Answer 9 · answered Mar 11 '19 at 16:05

0

When we run a C program, Computers control passes over to the C programs main() function, From there itself the C program starts to execute

answered Mar 11 '19 at 16:05

U.A

2,991
3
24
36

main() function in C

9 Answers9

Linked

Related