22.6.2 Accessing Command-Line Parameters

Why This Matters

Command-line parameters are a crucial aspect of C programming that allows you to pass arguments from the command line to your program. Understanding and using command-line parameters is essential for making C programs more versatile, user-friendly, and suitable for system administration tasks, scripting, and automation. This lesson will provide an in-depth exploration of command-line parameters, including practical examples, common mistakes, and practice questions to help you master this powerful feature.

Prerequisites

To fully grasp command-line parameters, it's important to have a solid understanding of the following concepts:

1. Basic C syntax and variables
2. Functions and function arguments
3. Compiling and running C programs
4. Understanding the command line and terminal
5. Data types in C (e.g., integers, floats, characters)
6. Control structures (if-else statements, loops)
7. Basic input/output operations
8. Error handling and exception management
9. String manipulation functions (e.g., strlen, strcmp)
10. Mathematical functions (e.g., trigonometric, logarithmic)

Core Concept

In C programming, command-line parameters are passed to your program through the main() function. The main() function has two parameters: int argc and char *argv[].

• argc is an integer that represents the number of arguments passed to the program. It always includes the name of the program itself as the first argument (argv[0]).
• argv is an array of strings, where each string represents a command-line argument. The first element of the array, argv[0], contains the name of the program.

Here's a simple example:

#include <stdio.h>

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

In this example, the program will print each command-line argument it receives. To run this program and pass arguments, you can compile it with a command like gcc main.c and then execute it with ./a.out arg1 arg2 arg3.

Accessing Individual Arguments

To access individual arguments, you can iterate through the argv array using a loop. The index i starts at 1 because argv[0] represents the program name itself.

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

Accessing the Number of Arguments

To find out how many arguments are passed to the program, you can use the argc variable. It contains the total number of arguments, including the program name (argv[0]).

int numArgs = argc;

Worked Example

Let's create a simple command-line calculator that accepts two numbers and an operation as arguments.

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

int main(int argc, char *argv[]) {
if (argc != 4) {
printf("Usage: %s number1 operator number2\n", argv[0]);
return 1;
}

double num1 = atof(argv[1]);
char op = argv[2][0];
double num2 = atof(argv[3]);

switch (op) {
case '+':
printf("%.2f + %.2f = %.2f\n", num1, num2, num1 + num2);
break;
case '-':
printf("%.2f - %.2f = %.2f\n", num1, num2, num1 - num2);
break;
case '*':
printf("%.2f * %.2f = %.2f\n", num1, num2, num1 * num2);
break;
case '/':
if (num2 == 0) {
printf("Error: Division by zero.\n");
return 1;
}
printf("%.2f / %.2f = %.2f\n", num1, num2, num1 / num2);
break;
default:
printf("Error: Invalid operator. Supported operators are +, -, *, and /.\n");
return 1;
}

return 0;
}

Save this code in a file called calculator.c, compile it with gcc calculator.c -o calc, and run it with examples like:

• ./calc 5 + 3
• ./calc 10 / 2
• ./calc 7 * 9

Common Mistakes

1. Forgetting to check the number of arguments: Always ensure that your program receives the expected number of arguments, as shown in the worked example.

if (argc != 4) {
printf("Usage: %s number1 operator number2\n", argv[0]);
return 1;
}

1. Converting command-line arguments to numbers incorrectly: Always use atof() or other appropriate functions to convert string arguments to their numerical equivalents.

double num1 = atof(argv[1]);
double num2 = atof(argv[3]);

1. Not handling division by zero: Always check for division by zero and handle it appropriately, as shown in the worked example.

if (num2 == 0) {
printf("Error: Division by zero.\n");
return 1;
}

1. Ignoring whitespace: Be aware that command-line arguments are delimited by whitespace, so you may need to handle spaces in your program's input.

1. Not validating user input: Always validate user input to ensure it is within acceptable ranges and meets specific criteria, such as only accepting numerical values for numbers or specific operators for operations.

1. Mismanaging memory: Be mindful of dynamically allocated memory when working with command-line arguments. Make sure to properly allocate, use, and free memory as needed.

Practice Questions

1. Write a program that accepts a filename as a command-line argument and prints its contents to the console.
2. Create a program that takes two numbers and an operation (addition, subtraction, multiplication, or division) as arguments and returns the result as a command-line output. The program should also handle input validation and error cases, such as invalid operators, division by zero, and non-numeric input for numbers.
3. Write a program that accepts a directory name as a command-line argument and lists all files within that directory, excluding hidden files (files starting with a dot).
4. Create a program that takes a filename as a command-line argument, reads the file line by line, and counts the number of occurrences of a specific word in the file. The program should also accept the word to search for as an additional command-line argument.
5. Write a program that accepts a list of filenames as command-line arguments, concatenates their contents into a single file, and saves it with a specified output filename (another command-line argument).
6. Create a program that takes two command-line arguments: a starting number and an ending number. The program should print the sum of all numbers between the two numbers (inclusive) using a loop.
7. Write a program that accepts a command-line argument representing a date in the format YYYYMMDD. The program should determine whether the provided date is a leap year or not and display an appropriate message.
8. Create a program that takes two command-line arguments: a starting number and an ending number. The program should print the product of all numbers between the two numbers (inclusive) using a loop.
9. Write a program that accepts a command-line argument representing a time in the format HHMMSS. The program should convert the provided time into a 12-hour format and display it with an AM or PM indicator, depending on whether the hour is greater than or equal to 12.

FAQ

1. Why do we need argc and argv in C programming?

• argc and argv are used to access command-line arguments passed to the program. They allow your program to accept input from the user at runtime, making it more versatile and user-friendly.

1. What is the difference between argc and argv in C programming?

• argc is an integer that represents the number of arguments passed to the program. It always includes the name of the program itself as the first argument (argv[0]). argv is an array of strings, where each string represents a command-line argument.

1. How can I check if a command-line argument exists in C programming?

• You can check if a command-line argument exists by comparing it with the first argument (argv[0]) or by checking its index against argc. For example, to check for an optional argument:

if (argc >= 3 && strcmp(argv[1], "option") == 0) {
// Do something with the option.
}

1. How can I handle command-line arguments that contain spaces in C programming?

• To handle command-line arguments containing spaces, you can use a loop to iterate through each character in the argument and check for whitespace (e.g., using isspace() from `). Then, you can join multiple words into a single string using a buffer or by concatenating strings with strcat()`.

1. How can I access command-line arguments containing special characters in C programming?

• To handle command-line arguments containing special characters, you can use escape sequences (e.g., \t for tab, \n for newline) or double the special character (e.g., \\ for backslash). Alternatively, you can enclose the argument in quotes to preserve the special characters as-is.

1. How can I pass command-line arguments with multiple words in C programming?

• To pass command-line arguments with multiple words, you should enclose them in quotes (e.g., "argument1 argument2"). This ensures that the space between the words is treated as a single argument instead of multiple separate arguments.

1. How can I pass environment variables as command-line arguments in C programming?

• To pass environment variables as command-line arguments, you can use the getenv() function to access the variable's value and then pass it as an argument to your program. For example:

#include <stdio.h>

int main(int argc, char *argv[]) {
char *myVar = getenv("MY_VAR");
printf("%s\n", myVar);
return 0;
}

1. How can I pass command-line arguments to a function in C programming?

• To pass command-line arguments to a function, you can define the function with a prototype that includes char *argv[] as an argument. Then, call the function within the main() function and pass the argv array as an argument. For example:

void myFunction(char *argv[]) {
// Function implementation using command-line arguments.
}

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