C Tutorial
.
What are command line arguments in C/C++? How to check command line arguments in C? Get your answers to all these questions through the below-mentioned article. You will also get to learn some of the various use cases and advantages of using command-line arguments in C.
Command-line arguments in C are typically responsible for passing arguments to a C program when it is executed from the terminal or the command line. They provide additional information to the program, enabling it to behave differently based on the input provided.
One of the most important functions of the C programming language is the main () function. It consists of two important parameters, namely,
argc and
argv
The ‘argc’, also referred to as argument count, is an integer variable. It stores the total number of command line arguments passed to the program, including the program name.
The ‘argv’, also known as the argument vector, is an array of strings. It holds the actual command line arguments as separate strings.
The syntax for both these parameters are,
int main(int argc, char *argv[]) { /* ... */ } |
and
int main(int argc, char **argv) { /* ... */ } |
Command line arguments allow flexibility and enable customisation of program behaviour without the need for making any changes to the source code itself. Apart from providing input data, they are also responsible for imparting configuration options, file names and any other information as and when required by the program during its runtime.
In C programming language, the function pointer can be defined as a specific variable responsible for storing the memory address of a function. It provides a way to achieve runtime polymorphism in C, where the specific function that needs to be executed can be determined according to the conditions or user input. Function pointers are widely used by programmers in C because it allows for implementing varied patterns such as event handling, function callbacks, and polymorphism, among others.
So how exactly does the function pointer work in C? Let’s find out!
The first and foremost step is to declare a function pointer. To achieve the same, you have to specify the return and the parameter types of the function it will be pointing to. Take this one, for example,
int (*funcPtr)(int, int); |
Here, we have declared the function pointer, ‘funcPtr’, by specifying the return type, which is ‘int’ and the parameter type, ‘int’, of the function.
Following this, we need to assign the address of a function to a function pointer. Going by this above-mentioned example, the syntax for the same will include the following,
int add(int a, int b) {
return a + b;
}
int (*funcPtr)(int, int) = add; |
Here, we have assigned the ‘add’ address to the function pointer, ‘funcPtr’.
Lastly, we invoke the function via a function pointer with the help of the function call operator (). So, the code will be,
int result = (*funcPtr)(3, 4); |
Please note that in order for the function pointer to be efficient, you need to assign the correct type of function address to it. Otherwise, it might generate or display undefined behaviour.
Command line arguments in C/C++ consist of the following properties,
They are received by the programs as strings, irrespective of the data type they represent.
The ‘argv[0]’ contains the name of the program itself.
Command line arguments are ordered in the same sequence they are provided in the command line.
The maximum number of command line arguments that can be passed on to a program usually depends on the operating system and the environment.
Command line arguments offer portability, meaning they can interact with C programs across various platforms.
The command line arguments will generate different outputs in a C program based on the specific implementation or the values provided. For example,
When No Command Line Arguments Are Provided
#include <stdio.h>
int main(int argc, char *argv[]) {
printf("Number of arguments: %d\n", argc);
printf("No additional command-line arguments provided.\n");
return 0;
} |
Output
Number of arguments: 1 No additional command-line arguments were provided. |
When Single Command Line Argument Is Provided
#include <stdio.h>
int main(int argc, char *argv[]) {
printf("Number of arguments: %d\n", argc);
if (argc > 1) {
printf("First command-line argument: %s\n", argv[1]);
} else {
printf("No additional command-line arguments provided.\n");
}
return 0;
} |
Output
$ ./program_name hello Number of arguments: 2 First command-line argument: hello |
When Multiple Command Line Arguments Are Provided
#include <stdio.h>
int main(int argc, char *argv[]) {
printf("Number of arguments: %d\n", argc);
if (argc > 1) {
printf("Command-line arguments:\n");
for (int i = 1; i < argc; i++) {
printf("Argument %d: %s\n", i, argv[i]);
}
} else {
printf("No additional command-line arguments provided.\n");
}
return 0;
} |
Output
$ ./program_name apple banana mango Number of arguments: 4 Command-line arguments: Argument 1: apple Argument 2: banana Argument 3: mango |
Command line arguments in C/C++ serve multiple purposes. From providing input data to language localisation, they are widely used by programmers working with C for a plethora of reasons. Let’s explore a few examples of using command line arguments in C.
Setting Program Options - Command line arguments in C can be used to specify the options or settings of a program. For example, you can pass a flag to enable a certain feature or configure the program’s behaviour.
Debugging or Testing - Command line arguments are also useful for enabling testing or debugging modes in a program. You can pass a flag that will trigger the desired debugging functionalities.
Batch Processing - Command line arguments are frequently used to automate the execution of a program with a set of predefined parameters. This makes dealing with batch-processing tasks or scripting much easier.
Overall, command line arguments provide a versatile mechanism for working with the C programming language. It offers both flexibility and customisation options for developers using C programs.
Let's see how to use command line arguments in a C program.
#include <stdio.h>
int main(int argc, char *argv[]) {
if (argc > 1) {
printf("Hello, %s!\n", argv[1]);
} else {
printf("Hello, World!\n");
}
return 0;
} |
In this example, the program expects a single command line argument that is treated as the name of the person to greet. If the command line argument is provided, then a customised greeting will be generated using that argument. If not, then a generic ‘Hello, World!’ greeting will be generated.
Output
$ ./program_name John Hello, John! |
There are several advantages to using command-line arguments in C. Some of them include,
Automation- Command line arguments facilitate the automation of program execution. You can create scripts to automate repetitive tasks by passing different arguments each time.
Reusability- With command line arguments, programs can be used in different contexts. They can be integrated into larger systems or used as standalone tools, providing a standardised interface for interaction.
User Interaction- Command line arguments in C also nullify the need for any graphical user interface by actively enabling programs to prompt users for inputs or display messages. For this reason, they can be used in embedded systems and remote servers.
Performance- Command line arguments are useful in performance-critical scenarios, as they can be processed very quickly and efficiently. This also leads to lightweight and efficient handling of user input.
Command line arguments play quite a crucial role in the C programming language. It not only provides a way for customising and automating several tasks but also simultaneously enhances their versatility and usability.
If you wish to learn more about the same, then do not forget to check out upGrad’s Executive PG Program In Software Development offered under the guidance of IIIT-B. From high-performance coaching to just-in-time interviews and access to the exclusive AI-powered profile builder, it provides numerous benefits to its students.
1. What are the different types of command line arguments used in C?
The main() function of C consists of two different command line arguments. They are, namely, argc and argv. The former denotes the total number of command line arguments, whereas the latter represents an array of command line arguments.
2. What are the disadvantages of command line arguments?
Although command-line arguments bear several advantages in C, there are a few downsides to it as well. For example, the commands have to be typed very precisely. In case any error occurs, you might have to start the whole process from scratch.
3. Can you state the first argument of the command line?
The ‘argv[1]’ is denoted as the first command line argument, whereas ‘argv[argc - 1] is viewed as the last argument in the command line.
Leave a Reply
Your email address will not be published. Required fields are marked *