What main() Should Return in C and C++

By the end of this page, you will understand the standard return type of main() in C and C++, which argument forms are valid, what exit codes mean, and why void main() should be avoided in portable programs.

In both C and C++, main() is the program's entry point. It is special: the language standards define how it should look and what its return value means.

The key rule is:

• main() should return int
• void main() is not standard in either C or C++

Why int?

Because when your program finishes, it returns a status code to the operating system. That status code tells the system whether the program succeeded or failed.

• 0 usually means success
• nonzero usually means some kind of error or abnormal situation

This matters in real programming because other programs, shell scripts, build tools, test runners, and operating systems often check a program's exit status.

For example:

• a build script may stop if your program returns a nonzero value
• a CI pipeline may mark a step as failed
• a shell script may run different logic depending on the result

In standard C, the common valid forms are:

int main(void)
int main(int argc, char *argv[])

In standard C++, the common valid forms are:

Think of main() like the front desk of a building.

• The operating system sends your program in through the front door.
• main() is the receptionist that handles the visit.
• When the program finishes, the receptionist sends back a small status note.

That note is the integer return value.

• 0 means: "Everything went fine."
• 1 or another nonzero value means: "Something went wrong" or "I finished with a warning/error state."

If main() were void, it would be like leaving the building without giving any status note back. Some compilers may allow it, but the official rules of C and C++ expect that note to be an integer.

Standard forms

C

int main(void)
{
    return 0;
}

int main(int argc, char *argv[])
{
    return 0;
}

C++

int main()
{
    return 0;
}

int main(int argc, char* argv[])
{
    return 0;
}

What the arguments mean

• argc = argument count
• argv = argument vector, an array of C-style strings

If you run a program like this:

Consider this example:

#include <stdio.h>

int main(int argc, char *argv[])
{
    if (argc < 2) {
        printf("Usage: program <name>\n");
        return 1;
    }

    printf("Hello, %s!\n", argv[1]);
    return 0;
}

Step by step:

1. The operating system starts the program and calls main.
2. It passes in:
   • argc, the number of command-line arguments
   • argv, the array of argument strings
3. The program checks if (argc < 2).
   • If true, the user did not provide the required extra argument.
4. If the argument is missing, the program prints a usage message.
5. It then executes return 1;.
   • This tells the operating system that the program did not complete successfully.
6. If the user did provide an argument, the condition is false.

Programs use main() return values constantly in real systems.

Command-line tools

A CLI tool may return:

• 0 when the command succeeded
• 1 when input was invalid
• another nonzero code for a specific failure

Build and automation scripts

Tools like shell scripts, Makefiles, and CI jobs often check exit codes.

Example idea:

• compile program
• run test executable
• if the test executable returns nonzero, fail the build

Server startup checks

A server process may return nonzero if:

• configuration file is missing
• database connection fails
• required port cannot be opened

Data processing programs

A batch job may return:

• 0 if all files were processed
• nonzero if one or more files failed

Educational and debugging tools

Programs that expect command-line arguments use argc and argv to read:

• file names
• modes like --verbose
• user input values

In real codebases, developers usually treat main() as a small coordinator function.

Common patterns include:

Guard clauses for startup validation

int main(int argc, char *argv[])
{
    if (argc < 2) {
        return 1;
    }

    return 0;
}

This is called an early return or guard clause. It exits quickly if startup conditions are not met.

Returning meaningful status codes

int main(void)
{
    if (!init_system()) {
        return 2;
    }

    if (!run_job()) {
        return 3;
    }

    return 0;
}

Different nonzero values can help scripts or developers identify the failure stage.

Delegating work to helper functions

main() is often kept short:

Using void main()

Broken example:

void main()
{
    printf("Hello\n");
}

Why it is a mistake:

• it is not standard C or C++
• it may work only on some compilers
• it does not correctly express an exit status

Use this instead:

int main(void)
{
    printf("Hello\n");
    return 0;
}

Returning 1 for success

Broken example:

int main(void)
{
    return 1;
}

Why it is a mistake:

• by convention and standard practice, 0 means success
• nonzero indicates failure or a special abnormal result

Use:

Correct forms

C

int main(void)
int main(int argc, char *argv[])

C++

int main()
int main(int argc, char* argv[])

Avoid

void main()

Return values

• return 0; → success
• return 1; or other nonzero value → failure or special error status

Arguments

• argc = number of arguments
• argv = array of strings
• argv[0] is usually the program name/path

Is void main() ever correct in C or C++?

No, not in standard C or standard C++. Some compilers may accept it as an extension, but portable code should not use it.

Should main() always return 0?

No. It should return 0 on success and a nonzero value when the program fails or wants to report a special status.

What does argc mean?

argc is the number of command-line arguments passed to the program, usually including the program name.

What is argv in main()?

argv is an array of C-style strings containing the command-line arguments.

Is int main() valid in C?

In C++, yes. In C, the preferred no-argument form is int main(void) because it explicitly states there are no parameters.

What is the difference between char *argv[] and char **argv?

For this use, they are equivalent ways to declare the argument list.

What should I return if an input file is missing?

• Program entry point — main() is the standard starting function for C and C++ programs.
• Exit status codes — closely related because main() communicates success or failure to the operating system.
• Command-line arguments — argc and argv are the standard way to receive input when a program starts.
• Function declarations — understanding parameter lists helps explain int main(void) versus int main().
• Portability — void main() often fails this principle because it relies on compiler-specific behavior.
• Guard clauses — common in main() for early validation and clean exits.
• Error handling — return codes are one of the simplest forms of reporting failure in C and C++.