main() function defined without return type gives warning

Question

This is my program:

main()
{ 
    printf(\"hello world\\n\");
}

I get this warning when compiling it:

function should retur         


        

Answer 1

Quick summary: If you don't want to use command-line arguments, you should write:

int main(void) {
    /* body of main function */
}

If you do:

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

These are the only portable ways to define the main function.

You should probably have a return 0; at the end, though it's not strictly necessary. Returning 0 indicates successful execution. There are ways to indicate that execution failed; I won't get into that here.

There's some history behind this. The rules for a valid definition of the main function have changed a bit across different releases of the C standard.

Before the introduction of the first official standard for C in 1989, the most common form was:

main()
{
    /* ... */
}

Or, if you wanted to use command-line arguments:

main(argc, argv)
/* argc is implicitly of type int */
char *argv[];
{
    /* ... */
}

There was no way to define a function that didn't return a value. If you didn't specify a return type, it defaulted to int.

The 1989 ANSI C standard (which was republished with editorial changes as the 1990 ISO C standard) introduced prototypes, function declarations and definitions that specify the parameter types. There are two equally valid definitions for main. You can use one or the other depending on whether you need to use command line arguments:

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

or

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

(char *argv[] can also be written as char **argv. This rule applies only to parameter definitions.)

A given compiler may or may not choose to permit other forms. For example, some compilers support a third parameter envp.

Somehow, some authors have gotten the idea that void main() or void main(void) is valid. It can be valid for some particular compiler, but only if that compiler explicitly supports it. It's not portable. The odd thing about this is that the same standard that first introduced the void keyword simultaneously established the rule that main's return type is int.

void main() is useful as an indicator that the author of the book you're reading doesn't know the C language very well, and that you should find another book.

The story is different for "freestanding" (embedded) systems. For such systems, the program's entry point is entirely implementation-defined, and might not even be called main. Defining it as void main(void) may well be valid for such systems.

The 1999 ISO C standard dropped the "implicit int" rule. Taking advantage of that rule was probably never a good idea in the first place. As of ISO C 1990, you could legally use:

main(void) { /* ... */ }

because it was equivalent to:

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

As of the 1999 standard, the int is mandatory.

The 1999 standard also added a special-case rule: reaching the closing } of the main function is equivalent to executing return 0;. It's still not a bad idea to add the explicit return 0;, especially if your code might be compiled with a pre-C99 compiler.

The 2011 ISO C standard didn't make any changes in this area.

The difference between int main() and int main(void) is that the latter explicitly says that main takes no arguments; the former doesn't specify how many arguments it takes. Use the int main(void) form. There have been debates about whether int main() is even legal.

You can likely get away with writing void main(), since it's an error that compilers are not actually required to diagnose (it's undefined behavior unless the implementation documents it).

The bottom line: The proper definition of main has a long and varied history, and there are a lot of variant forms you can probably get away with using. But unless you're programming for an embedded system, there is no point in using anything other than one of the two officially valid forms:

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

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