Command Line Arguments

Why This Matters

Command line arguments are your gateway to building real-world, production-quality programs in C. Every professional tool you use—from gcc to git to ls—relies on command line arguments to accept user input without hardcoding values. You're being tested on your ability to understand how programs receive external data, how arrays of pointers work in practice, and how to write robust code that handles unexpected input gracefully.

This topic connects directly to core C concepts: pointers, arrays, string manipulation, and memory safety. When you master command line arguments, you're demonstrating that you can work with char* arrays, iterate through data structures, and convert between types—all skills that appear repeatedly in exams and technical interviews. Don't just memorize the syntax—know why argv is a pointer to pointers and how argument validation prevents crashes.

---

The Foundation: argc and argv

Every C program with command line support starts with two special parameters passed to main(). These form the interface between your program and the operating system's shell. The system parses the command line and delivers the results to your program in a standardized format.

argc (Argument Count)

• Integer representing total arguments passed—always includes the program name, so minimum value is 1
• First check in any argument-handling code—use argc to verify you received the expected number of inputs before accessing argv
• Enables defensive programming—comparing argc against expected values prevents array out-of-bounds errors

argv (Argument Vector)

• Array of character pointers (char* argv[] or char** argv)—each element points to a null-terminated string
• argv[0] always contains the program name—actual user arguments start at argv[1]
• argv[argc] is guaranteed to be NULL—this sentinel value enables pointer-based iteration as an alternative to index-based loops

---

Accessing and Iterating Through Arguments

Once you understand the structure, you need to know how to actually retrieve and process the data. C provides multiple idiomatic patterns for traversing the argument array.

Index-Based Access

• Use bracket notation argv[i]—most readable approach for beginners and when you need specific argument positions
• Loop from 1 to argc - 1 to skip program name—common pattern: for (int i = 1; i < argc; i++)
• Each argv[i] is a complete string—you can pass it directly to functions like printf() or strcmp()

Pointer-Based Iteration

• Increment argv pointer directly—argv++ advances to the next argument string
• Check for NULL terminator—loop condition while (*argv) works because argv[argc] == NULL
• More idiomatic for experienced C programmers—demonstrates understanding of pointer arithmetic

---

Type Conversion Functions

Command line arguments arrive as strings, but programs often need numeric data. C provides standard library functions to convert string representations to numeric types.

atoi() and atol()

• Convert strings to integers—atoi("42") returns the int value 42
• No error detection built in—returns 0 for invalid input, which is indistinguishable from the string "0"
• Defined in <stdlib.h>—must include this header to use these functions

strtol() and strtod()

• Safer conversion with error checking—second parameter captures where parsing stopped, third (for strtol) specifies base
• Detects overflow and invalid input—check errno and the end pointer to verify successful conversion
• Preferred for production code—demonstrates understanding of robust programming practices

sscanf()

• Flexible formatted parsing—can extract multiple values and different types from a single string
• Returns count of successfully parsed items—enables validation by checking return value
• Defined in <stdio.h>—useful when argument format is complex or contains multiple fields

---

Validation and Error Handling

Professional programs don't crash when users provide bad input. Defensive programming requires checking arguments before using them.

Argument Count Validation

• Check argc before accessing argv elements—prevents undefined behavior from out-of-bounds access
• Provide usage messages when arguments are wrong—standard pattern: if (argc != expected) { fprintf(stderr, "Usage: ..."); return 1; }
• Use meaningful exit codes—return 0 for success, non-zero values for different error conditions

Input Format Validation

• Verify converted values are in acceptable ranges—a valid integer might still be outside your program's expected bounds
• Check for empty strings and edge cases—argv[i][0] == '\0' detects empty arguments
• Use strcmp() for string matching—validate flag arguments like "-h" or "--help" with string comparison

---

Common Conventions and Patterns

Real-world programs follow established conventions that users expect. Understanding these patterns helps you write professional-quality interfaces.

Flag and Option Formats

• Single-dash flags use one character—-v for verbose, -h for help; can often be combined like -vh
• Double-dash options use full words—--output filename or --help; more readable but longer to type
• Double-dash alone (--) signals end of options—everything after is treated as positional arguments, not flags

Usage Messages and Help

• Print to stderr, not stdout—error and usage messages shouldn't mix with program output
• Include program name from argv[0]—makes usage message accurate regardless of how program is invoked
• Show required vs. optional arguments clearly—convention: <required> in angle brackets, [optional] in square brackets

---

Quick Reference Table

---

Self-Check Questions

1. What is the minimum value of argc, and why can't it ever be zero?

2. Compare atoi() and strtol(): which would you use if you needed to detect whether the user passed an invalid (non-numeric) argument, and why?

3. If a program is invoked as ./myprogram input.txt output.txt, what are the values of argc, argv[0], argv[1], and argv[2]?

4. Why should you check argc before accessing elements of argv? What could happen if you skip this validation?

5. Write pseudocode (or describe the logic) for a program that accepts an optional -v flag and a required filename argument, printing a usage message if the arguments are invalid.