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
$ 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] = 256. Key Takeaways
main(int argc, char *argv[])is the standard signature for accepting command line input.argccounts all tokens including the program name;argv[0]is the program name itself.- Every element of
argvis a null-terminated string, even numeric-looking arguments. argv[argc]is guaranteed to beNULL, giving a safe alternative loop-termination check.- Use
strtol/strtodoveratoi/atofwhen you need to detect invalid numeric input. - Always validate
argcbefore indexing intoargvto avoid undefined behavior.
Practice what you learned
1. What is the correct standard signature for `main` to accept command line arguments in C?
2. For the invocation `./sum 10 20 30`, what is the value of argc?
3. What does argv[0] represent?
4. Why is `strtol` often preferred over `atoi` when converting command line arguments to integers?
5. What is guaranteed about argv[argc]?
Was this page helpful?
You May Also Like
Pointers in C
Learn C pointers with syntax, address-of and dereference operators, pointer arithmetic, and common pitfalls, with examples and output.
Strings in C
Master C strings: null-terminated char arrays, string literals vs char arrays, key string.h functions, and buffer-overflow pitfalls.
Functions in C
Learn C functions: declaration vs definition, parameters, pass-by-value, return statements, and prototypes with examples.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics