The main() Function in C: Role, Signatures, argc/argv & Exit Codes Explained

The Role of main(): Why It Exists

When the operating system runs a program, it needs a defined place to start. Different languages solve this differently — Python executes the script file top-to-bottom, Java looks for public static void main(String[] args), JavaScript runs from the first line.

C's solution is main() — a function with a specific name that the OS runtime is designed to call as the first function of your program. It is not special because of any language magic; it is special because the C runtime startup code (part of the C standard library) is hardcoded to call a function named main after finishing its own initialization.

This is why every C program must have exactly one main(): it is the agreed contract between the C runtime and your code. If you don't define it, the linker reports "undefined reference to main". If you define it twice, the linker reports "multiple definition of main". There is exactly one entry point, no exceptions.

What Happens Before main() Runs

The path from "the OS launches your program" to "your first line of main() executes" involves several steps most developers never think about. Understanding this sequence explains some otherwise-mysterious C behaviors — like why global variables are already initialized when main() starts.

The Two Valid Signatures for main()

The C standard (C99, C11, C17, C23) defines exactly two valid forms of main(). Any other form is non-standard, even if some compilers accept it.

/* Signature 1 — no command-line arguments needed */
int main(void) {
    return 0;
}

/* Signature 2 — receives command-line arguments */
int main(int argc, char *argv[]) {
    return 0;
}

/* Also valid — alternative argv declaration syntax */
int main(int argc, char **argv) {
    return 0;
}

argc and argv: Command-Line Arguments

When a user runs a C program from the terminal with arguments, those arguments are delivered to main() through argc and argv. This is how every command-line tool you've ever used — gcc, ls, git — receives its options and file paths.

What argc and argv contain

argc (argument count) is the total number of strings in argv. It is always at least 1 because argv[0] is always the program's name (or path).

argv (argument vector) is an array of char* pointers, each pointing to a null-terminated string. argv[argc] is always a NULL pointer — a guaranteed sentinel you can use to iterate without knowing argc.

#include <stdio.h>
#include <stdlib.h>   // atoi()

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "Usage: %s <num> <op> <num>\n", argv[0]);
        return 1;   // non-zero = failure
    }

    int a  = atoi(argv[1]);   // convert string "10" → int 10
    char op = argv[2][0];     // first char of argv[2] ("+", "-", etc.)
    int b  = atoi(argv[3]);

    int result;
    switch (op) {
        case '+': result = a + b; break;
        case '-': result = a - b; break;
        case '*': result = a * b; break;
        default:
            fprintf(stderr, "Unknown operator: %c\n", op);
            return 1;
    }

    printf("%d %c %d = %d\n", a, op, b, result);
    return 0;
}

./calc 10 + 5
10 + 5 = 15

./calc 20 - 8
20 - 8 = 12

./calc
Usage: ./calc <num> <op> <num>

Iterating over all arguments

/* Style 1: index-based */
for (int i = 0; i < argc; i++) {
    printf("argv[%d] = %s\n", i, argv[i]);
}

/* Style 2: pointer-based (uses the NULL sentinel) */
for (char **arg = argv; *arg != NULL; arg++) {
    printf("%s\n", *arg);
}

Return Values and Exit Codes

The integer main() returns becomes the program's exit code — a signal sent to the OS when your program finishes. This is one of the most important interfaces between a C program and the outside world.

# Check last program's exit code
./myprogram
echo $?          # Linux/macOS: prints 0 if success, 1 if failure

# Use in a shell script condition
if ./myprogram; then
    echo "Program succeeded"
else
    echo "Program failed with code $?"
fi

# CI/CD: a non-zero exit code fails the build step
# GitHub Actions, Jenkins, and GitLab CI all use this convention

What Happens After main() Returns

When main() returns, the C runtime doesn't immediately hand control back to the OS. It performs an ordered cleanup sequence:

1. atexit() handlers run — functions registered with atexit() are called in reverse registration order (last registered = first called). Use this for cleanup like flushing logs or releasing shared resources.
2. stdio buffers are flushed — all open FILE streams are flushed. This is why printf output always appears even without an explicit fflush(stdout) — the runtime flushes it at exit.
3. Open FILE streams are closed — including stdin, stdout, and stderr.
4. The exit code is passed to the OS — the integer returned from main() becomes the process exit status.

#include <stdio.h>
#include <stdlib.h>

void cleanup_log()  { printf("Log flushed.\n"); }
void cleanup_db()   { printf("DB connection closed.\n"); }

int main() {
    atexit(cleanup_log);   // registered first
    atexit(cleanup_db);    // registered second

    printf("Program running...\n");
    return 0;

    // Output:
    // Program running...
    // DB connection closed.   ← last registered, first called
    // Log flushed.
}

main() in Embedded Systems

In embedded systems programming, the rules around main() are slightly different. On a bare-metal microcontroller — no operating system, no C runtime startup code — there is no OS waiting to receive the exit code when main() returns.

For this reason, embedded main() functions almost always contain an infinite loop — the hardware has no concept of "exit". If main() returned, the CPU would start executing whatever is in memory after the program — random code, causing undefined behavior or a processor fault.

int main(void) {
    hardware_init();   // set up clocks, GPIO, peripherals

    while (1) {        // infinite loop — never returns
        read_sensors();
        update_outputs();
        WDT_Kick();       // kick watchdog timer
    }

    return 0;  // never reached, but required by some compilers
}

Common main() Mistakes

Frequently Asked Questions