Command Line Arguments in C

Analogy categoryAnalogies

1. Introduction

Command line arguments are values passed to a C program at the moment it is launched from a terminal or shell, rather than being typed in interactively while the program runs. They let the same compiled executable behave differently depending on how it is invoked — for example, gcc file.c -o out passes file.c and -o out as arguments to the gcc compiler itself. In C, command line arguments are captured through two special parameters of the main function, conventionally named argc (argument count) and argv (argument vector). Mastering them is essential for writing utilities, scripts, and tools that behave like real Unix/Linux or Windows command-line programs.

🏏

Cricket analogy: Like the toss captain announcing 'bat first' before the match starts, command line arguments tell a compiled program how to behave the instant it is launched, without the umpire re-briefing players mid-over.

2. Syntax

To accept command line arguments, main must be declared with two parameters instead of none. The standard, portable form is:

🏏

Cricket analogy: Declaring main with two parameters is like a team sheet that always has two fixed slots, captain and vice-captain, filled in before the match toss even happens.

int main(int argc, char *argv[]) {
    // argc: number of arguments including the program name
    // argv: array of C-string pointers, one per argument
    return 0;
}

argc is an int holding the total count of tokens on the command line, and argv is an array of char * (equivalently char **argv) where each element points to a null-terminated string. By convention argv[0] is always the name (or path) used to invoke the program, argv[1] through argv[argc-1] are the actual arguments supplied by the user, and argv[argc] is guaranteed by the C standard to be a NULL pointer, which is useful as a sentinel when iterating without relying on argc.

🏏

Cricket analogy: argc as the total token count is like the umpire's count of legal deliveries in an over, while argv is the lineup of batters each holding their own scorecard, with argv[0] being the team name itself and a null pointer marking the innings' end.

3. Explanation

When you run a program as ./greet Alice 25, the operating system splits the input on whitespace (respecting quotes) and hands the resulting tokens to the C runtime, which populates argc and argv before calling main. Here argc would be 3, argv[0] is "./greet", argv[1] is "Alice", and argv[2] is "25". Every element of argv is always a string — even something that looks numeric like "25" is stored as the characters '2', '5', '\0', not as an int. This is why converting arguments to numeric types is a routine and important task: functions such as atoi, atof, and especially strtol/strtod parse a string and return the corresponding numeric value. strtol is generally preferred over atoi in production code because it can detect conversion errors (via an endptr parameter) and supports different number bases, whereas atoi silently returns 0 on invalid input with no way to distinguish a real zero from a parsing failure.

🏏

Cricket analogy: Running './greet Alice 25' is like handing the scorer a slip reading 'match, Sachin, 100' where every field is text on paper, so even '100' must be parsed into a real number before it's added to a batting average, the way strtol parses safely versus atoi which just guesses.

Always check argc before dereferencing any argv[i] with i >= 1. Accessing argv[1] when the user supplied no arguments (argc == 1) reads out of bounds and is undefined behavior — it may crash, or worse, silently read garbage memory. A defensive pattern is if (argc < 2) { fprintf(stderr, "Usage: %s <name>\n", argv[0]); return 1; } before touching any indexed argument.

Tip: for anything beyond a couple of positional arguments, consider using getopt() (POSIX) to parse flags like -v or --output file.txt in a standard, robust way instead of hand-rolling a loop over argv.

4. Example

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

int main(int argc, char *argv[]) {
    if (argc < 3) {
        fprintf(stderr, "Usage: %s <name> <age>\n", argv[0]);
        return 1;
    }

    /* argv[1] and argv[2] are still strings here */
    const char *name = argv[1];

    char *endptr;
    long age = strtol(argv[2], &endptr, 10);

    if (*endptr != '\0') {
        fprintf(stderr, "Error: '%s' is not a valid integer\n", argv[2]);
        return 1;
    }

    printf("Program name : %s\n", argv[0]);
    printf("Argument count (argc): %d\n", argc);
    printf("Hello, %s! You are %ld years old.\n", name, age);

    printf("All arguments:\n");
    for (int i = 0; i < argc; i++) {
        printf("  argv[%d] = %s\n", i, argv[i]);
    }

    return 0;
}

5. Output

text

$ gcc greet.c -o greet
$ ./greet Alice 25
Program name : ./greet
Argument count (argc): 3
Hello, Alice! You are 25 years old.
All arguments:
  argv[0] = ./greet
  argv[1] = Alice
  argv[2] = 25

6. Key Takeaways

main(int argc, char *argv[]) is the standard signature for accepting command line input.
argc counts all tokens including the program name; argv[0] is the program name itself.
Every element of argv is a null-terminated string, even numeric-looking arguments.
argv[argc] is guaranteed to be NULL, giving a safe alternative loop-termination check.
Use strtol/strtod over atoi/atof when you need to detect invalid numeric input.
Always validate argc before indexing into argv to avoid undefined behavior.