💻 18. Command Line Arguments

18.1 What Are Command Line Arguments?

Command line arguments are values supplied to a C program when the program starts. They let the program receive input from the command that launches it, instead of asking for that input later with scanf().

program.exe 10 20 30

Here 10, 20, and 30 are supplied to the program as command line arguments.

18.2 The main() Function

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

18.3 Understanding argc

Suppose the program is started as:

program.exe 10 20

Conceptually:

For a normal terminal launch, the program-name string is at argv[0]. Therefore, two user-supplied values normally make argc == 3.

18.4 Understanding argv

Think of argv as a table of strings:

argv[i] points to character text. The characters "25" must be converted before they can be used as the integer 25 in a numeric calculation.

18.5 Displaying Command Line Arguments

#include <stdio.h>

int main(int argc, char *argv[])
{
    for (int i = 0; i < argc; i++)
        printf("argv[%d] = %s\n", i, argv[i]);

    return 0;
}

For program.exe apple 25, the program can display the arguments in order. The loop is safe because it stays within 0 ... argc - 1.

18.6 The Most Important Rule: Arguments Are Strings

So this is wrong when numeric arithmetic is required:

int sum = argv[1] + argv[2];

Convert the text, check whether conversion succeeded, and then calculate. Checking the argument count alone does not validate the contents.

18.7 Converting an Argument with atoi()

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

int main(int argc, char *argv[])
{
    if (argc != 3)
        return 1;

    int a = atoi(argv[1]);
    int b = atoi(argv[2]);

    printf("%d\n", a + b);
    return 0;
}

atoi() is used in the short calculation examples only with valid, in-range numeric arguments. It cannot distinguish a valid zero from many invalid inputs and does not provide reliable range checks. When validating input, prefer strtol().

18.8 strtol() — Safer Integer Conversion

#include <errno.h>
#include <limits.h>
#include <stdlib.h>

char *end;
errno = 0;
long value = strtol(argv[1], &end, 10);

if (errno == ERANGE || end == argv[1] || *end != '\0')
{
    /* invalid or out-of-range integer */
}

The useful idea is not merely conversion; it is validation. strtol() reports where conversion stopped through an end pointer. Check that at least one digit was read, no unwanted characters remain, and no range error occurred.

18.9 Adding Two Command Line Numbers

For a program started as program.exe 10 20:

int a = atoi(argv[1]);
int b = atoi(argv[2]);
printf("Sum = %d\n", a + b);

Before accessing argv[1] and argv[2], verify that the required arguments exist.

18.10 Subtraction, Multiplication and Division

a - b

a * b

a / b

18.11 Processing Multiple Numeric Arguments

Once each argument has been converted, normal C algorithms can process them.

long sum = 0;
for (int i = 1; i < argc; i++)
    sum += strtol(argv[i], NULL, 10);

The sum or search algorithm is the same as with keyboard input. Only the way the initial values reach the program changes. Validate the argument strings before passing their converted values into that algorithm.

18.12 Finding Maximum and Minimum

First check that at least one data argument exists. Initialize both results from that value, then compare the remaining values. Starting maximum at zero would fail for an all-negative list.

long max = strtol(argv[1], NULL, 10);

for (int i = 2; i < argc; i++)
{
    long value = strtol(argv[i], NULL, 10);
    if (value > max)
        max = value;
}

This also works correctly when all supplied numbers are negative.

18.13 Average of Command Line Numbers

long sum = 0;
for (int i = 1; i < argc; i++)
    sum += strtol(argv[i], NULL, 10);

double average = (double)sum / (argc - 1);

Convert an operand before dividing if you need a fractional average. Storing an already truncated integer quotient in a double cannot recover its lost fraction.

18.14 Passing Words and Text

Arguments do not have to be numbers. They can be names, commands, modes, file names or other text.

program.exe hello CodeBhavya

Then argv[1] is "hello" and argv[2] is "CodeBhavya".

18.15 Arguments Containing Spaces

Most shells split unquoted spaces into separate arguments. Quote text such as "C Programming" when it should be received as one argument.

program.exe "CodeBhavya C Programming"

The shell normally removes the grouping quotes before launching the program. The exact quoting rules depend on the shell; the C program receives the resulting strings through argv.

18.16 Checking the Number of Arguments

Never access an argument index that is not available.

if (argc != 3)
{
    printf("Usage: program number1 number2\n");
    return 1;
}

18.17 Command Line Argument Diagram

18.18 Command Line Arguments vs scanf()

18.19 Building a Command Line Calculator

A small calculator can accept an operator and two operands:

program.exe 12 + 5

A good design is:

18.20 Passing a File Name

program.exe students.txt

Then argv[1] can be used as the file name passed to functions such as fopen(). This connects command-line arguments with practical file-processing utilities.

18.21 A Reliable Problem-Solving Method

18.22 Common Command Line Mistakes

• Using argv[1] without checking argc.
• Forgetting that argv contains strings.
• Trying to perform numeric arithmetic directly on argument strings.
• Assuming argv[0] is a user-supplied value.
• Using atoi() when detailed validation is required.
• Forgetting division-by-zero checks.
• Using an incorrect loop boundary and reading past argv[argc - 1].
• Ignoring negative values when calculating minimum or maximum.
• Forgetting that spaces can separate arguments at the command-line level.

18.23 Interview-Level Understanding

Treat an argument as input to be checked, just like a typed value or a file record. Conversion checks and arithmetic checks are separate: even two valid integers can overflow when added.

18.24 CodeBhavya Rule

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

int main(int argc, char *argv[])
{
    if (argc != 2) { fputs("Usage: program NUMBER\n", stderr); return 1; }
    char *end;
    errno = 0;
    long n = strtol(argv[1], &end, 10);
    if (end == argv[1] || *end != '\0' || errno == ERANGE ||
        n < INT_MIN || n > INT_MAX) {
        fputs("Invalid integer\n", stderr);
        return 1;
    }
    printf("Number: %ld\n", n);
    return 0;
}

Number: 25

18.26 Quick Revision

INTERACTIVE LEARNING

🎬 Command Line Arguments — argc & argv Flow

Follow how terminal arguments become argc and argv values inside main().

▶ Open Visualization

—

18.27 Quick MCQs

Select an answer first, then click Check Answer. A correct choice becomes green. If the answer is wrong, your choice becomes red and the correct option becomes green. The explanation appears below.

Run your program to see the output.

#include <stdio.h>

int main(int argc, char *argv[])
{
    for (int i = 1; i < argc; i++)
    {
        printf("%s", argv[i]);

        if (i < argc - 1)
            printf("\n");
    }

    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("argc = %d\n", argc);
    printf("argv[0] = <program>");

    for (int i = 1; i < argc; i++)
        printf("\nargv[%d] = %s", i, argv[i]);

    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        printf("Missing Argument");
        return 0;
    }

    printf("%s", argv[1]);
    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    if (argc != 3)
        return 1;

    int a = atoi(argv[1]);
    int b = atoi(argv[2]);

    printf("%d", a + b);
    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    if (argc != 3)
        return 1;

    printf("%d", atoi(argv[1]) - atoi(argv[2]));
    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    if (argc != 3)
        return 1;

    long a = strtol(argv[1], NULL, 10);
    long b = strtol(argv[2], NULL, 10);

    printf("%ld", a * b);
    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    if (argc != 3)
        return 1;

    double a = strtod(argv[1], NULL);
    double b = strtod(argv[2], NULL);

    if (b == 0.0)
    {
        printf("Division by zero");
        return 0;
    }

    printf("%.2f", a / b);
    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    long sum = 0;

    for (int i = 1; i < argc; i++)
        sum += strtol(argv[i], NULL, 10);

    printf("%ld", sum);
    return 0;
}

Run your program to see the output.

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

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

    double sum = 0.0;

    for (int i = 1; i < argc; i++)
        sum += strtod(argv[i], NULL);

    printf("%.2f", sum / (argc - 1));
    return 0;
}

Run your program to see the output.

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

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

    long maximum = strtol(argv[1], NULL, 10);

    for (int i = 2; i < argc; i++)
    {
        long value = strtol(argv[i], NULL, 10);
        if (value > maximum)
            maximum = value;
    }

    printf("%ld", maximum);
    return 0;
}

Run your program to see the output.

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

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

    long minimum = strtol(argv[1], NULL, 10);

    for (int i = 2; i < argc; i++)
    {
        long value = strtol(argv[i], NULL, 10);
        if (value < minimum)
            minimum = value;
    }

    printf("%ld", minimum);
    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    int count = 0;

    for (int i = 1; i < argc; i++)
    {
        long value = strtol(argv[i], NULL, 10);
        if (value % 2 == 0)
            count++;
    }

    printf("%d", count);
    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    int positive = 0;
    int negative = 0;

    for (int i = 1; i < argc; i++)
    {
        long value = strtol(argv[i], NULL, 10);

        if (value > 0)
            positive++;
        else if (value < 0)
            negative++;
    }

    printf("Positive = %d\nNegative = %d", positive, negative);
    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    if (argc != 4)
        return 1;

    double a = strtod(argv[1], NULL);
    char op = argv[2][0];
    double b = strtod(argv[3], NULL);

    switch (op)
    {
        case '+': printf("%.2f", a + b); break;
        case '-': printf("%.2f", a - b); break;
        case '*': printf("%.2f", a * b); break;
        case '/':
            if (b == 0.0) printf("Division by zero");
            else printf("%.2f", a / b);
            break;
        default: printf("Invalid operator");
    }

    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    if (argc != 3)
        return 1;

    double marks = strtod(argv[2], NULL);

    printf("Name = %s\nMarks = %.1f", argv[1], marks);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

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

    FILE *fp = fopen(argv[1], "w");

    if (fp == NULL)
    {
        printf("Open Failed");
        return 0;
    }

    printf("File Opened");
    fclose(fp);
    return 0;
}

Run your program to see the output.

#include <stdio.h>

int main(int argc, char *argv[])
{
    (void)argv;
    printf("%d", argc - 1);
    return 0;
}

Run your program to see the output.

#include <stdio.h>
#include <string.h>

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

    int best = 1;

    for (int i = 2; i < argc; i++)
    {
        if (strlen(argv[i]) > strlen(argv[best]))
            best = i;
    }

    printf("%s", argv[best]);
    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    for (int i = 1; i < argc; i++)
    {
        char *end;
        errno = 0;
        long value = strtol(argv[i], &end, 10);

        if (errno == ERANGE || end == argv[i] || *end != '\0')
        {
            printf("Invalid: %s", argv[i]);
            return 0;
        }

        (void)value;
    }

    printf("Valid");
    return 0;
}

Run your program to see the output.

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

int main(int argc, char *argv[])
{
    if (argc != 5)
        return 1;

    double m1 = strtod(argv[2], NULL);
    double m2 = strtod(argv[3], NULL);
    double m3 = strtod(argv[4], NULL);
    double total = m1 + m2 + m3;
    double average = total / 3.0;
    char grade;

    if (average >= 90) grade = 'A';
    else if (average >= 75) grade = 'B';
    else if (average >= 60) grade = 'C';
    else if (average >= 50) grade = 'D';
    else grade = 'F';

    printf("Name = %s\n", argv[1]);
    printf("Total = %.1f\n", total);
    printf("Average = %.2f\n", average);
    printf("Grade = %c", grade);

    return 0;
}

18.29 Key Takeaway