Why you should use ‘int main()’ in C

Don’t Be Void-Minded: Why `int main()` is the Standard, Smarter Way to Start Your C Programs

If you’ve spent any time learning C, you’ve probably encountered different ways to define your program’s entry point. The two most common contenders are void main() and int main(). While void main() might compile on some systems (and unfortunately, still gets taught in some circles), it’s crucial for any aspiring or professional C programmer to understand why int main() is the unequivocally correct, standard, and preferred way to start your C applications.

Let’s dive into the reasons why you should always embrace int main().

The C Standard Demands It: Compliance is Key

This is the bedrock of the argument. The C language standard, as defined by ISO/IEC (e.g., C90, C99, C11, C17, and the upcoming C23), explicitly specifies the valid signatures for the main function. There are generally two forms:

int main(void): For programs that don’t need command-line arguments.
int main(int argc, char argv[]): For programs that do* need command-line arguments.

Notice a common theme? Both start with int. The C standard does not list void main() as a valid signature for the program’s entry point. Compiling void main() usually means your compiler is either offering it as a non-standard extension (which ties your code to that specific compiler) or operating in a very lax mode.

Why does this matter? Adhering to the standard ensures your code is portable and will compile and behave consistently across different compilers, operating systems, and platforms.

Communicating with the World: The Power of the Exit Status

Perhaps the most practical reason for int main() is its ability to return an exit status to the operating system or the calling process.

When your main function returns an int value, that integer communicates the program’s success or failure:

0 (or EXIT_SUCCESS from <stdlib.h>): Conventionally indicates that the program executed successfully without any errors.
Non-zero value (e.g., 1, 2, or EXIT_FAILURE from <stdlib.h>): Conventionally indicates that the program encountered an error or a specific problem during execution. Different non-zero values can even signify different types of errors.

Imagine this scenario: You have a shell script that runs multiple C programs in a sequence. If one program fails, the script needs to know so it can stop or take corrective action. How does it know? By checking the exit status!

#!/bin/bash

./my_c_program_step1
if [ $? -ne 0 ]; then
    echo "Error in step 1, aborting!"
    exit 1
fi

./my_c_program_step2
if [ $? -ne 0 ]; then
    echo "Error in step 2, aborting!"
    exit 1
fi

echo "All steps completed successfully!"

If main were void, your C program would have no standard way to inform the calling environment about its execution outcome. It’s like a person finishing a task but never telling you if they succeeded or failed. You’d have to guess!

Portability is Your Friend, `void main()` is Not

While void main() might work with certain compilers (especially older versions or those targeting very specific embedded systems where the concept of “exiting” might not apply in the same way), it’s far from universal.

Relying on void main() is a recipe for portability headaches:

Your code might compile perfectly fine with GCC on Linux, but refuse to compile with Microsoft Visual C++ on Windows, or clang on macOS.
Even if it compiles, its behavior might be undefined or inconsistent.
Future compiler versions might drop support for such non-standard extensions, breaking your code down the line.

Sticking to int main() ensures that your C code is robust and can be easily compiled and run across a wide range of environments without modification.

Good Practice and Readability

Even if you don’t immediately need the exit status, using int main() is a sign of good programming hygiene. It clearly communicates to anyone reading your code (including your future self) that the program is designed to terminate and can report its status. It’s a small detail, but these small details contribute to well-structured, maintainable, and professional code.

The “But I Saw It Somewhere!” Argument (and why it’s usually wrong)

You might legitimately have seen void main() in:

Very old textbooks or tutorials: Some legacy resources predate or ignore modern C standards.
Specific embedded systems examples: In deeply embedded contexts, a program might run forever in an infinite loop and never truly “exit” to an OS. Even then, int main() with an infinite loop inside is still more compliant.
Non-standard compiler extensions: Some compilers offer void main() as an extension to the C standard. Relying on extensions makes your code non-portable.

In almost all modern C programming scenarios, especially for applications running on general-purpose operating systems, these historical or niche exceptions do not justify deviating from the standard.

A Simple Example

Here’s how int main() looks in practice:

#include <stdio.h>  // For printf
#include <stdlib.h> // For EXIT_SUCCESS, EXIT_FAILURE

int main(void) {
    printf("Hello from a standard C program!\n");

    // Your program's logic goes here
    // ...

    // Indicate successful execution
    return EXIT_SUCCESS; // This is equivalent to 'return 0;'
}

// Another common form, accepting command-line arguments:
/*
int main(int argc, char *argv[]) {
    if (argc > 1) {
        printf("Hello, %s!\n", argv[1]);
        return EXIT_SUCCESS;
    } else {
        fprintf(stderr, "Usage: %s <name>\n", argv[0]);
        return EXIT_FAILURE; // Indicate an error due to incorrect usage
    }
}
*/

Conclusion

The int in int main() isn’t just a suggestion; it’s a fundamental aspect of writing robust, standard-compliant, and portable C code. It allows your program to communicate effectively with its environment, making it a well-behaved citizen in the software ecosystem.

So, the next time you fire up your C editor, remember the int main() mantra. Make it your non-negotiable standard. Your compilers, your colleagues, and your future self will thank you for it!

Happy coding, and may your programs always exit gracefully!

Don’t Be Void-Minded: Why int main() is the Standard, Smarter Way to Start Your C Programs