Programs

Command Line Arguments in C Explained

Command-line arguments are used when a program needs to be controlled from the outside instead of internally. It is a text interface for developers where arguments are directly passed to the primary method. 

The values that are passed within a function when it is called are termed as arguments. In other words, an argument is a parameter that is passed to a given method when invoked.

Syntax

int main() { /* … */ }

The above code receives the command and passes it off to the computer’s operating system to run. These commands are always invoked when a code is being executed. 

CC and C++ command-line arguments are pretty easy to implement because of their simplicity and easily decipherable syntaxes. 

To pass command line arguments, the main function needs to be defined by two arguments: 

  1. The total number of command-line arguments 
  2. The entire list of command-line arguments

Syntax:

int main(int argc, char *argv[]) { /* … */ }

  1. argc (ARGument Count) is defined as an integer data type that stores the total number of command-line arguments. Understandably, this should always be a non-negative value.
  2. argv (ARGument Vector) denotes an array of pointers of the character data type used to store the entire list of command-line arguments. 

With the help of the command line, developers can access a range of files and folders on their computers. A given program that contains several command-line arguments may quickly identify the sources or destinations of the given data. It also has the potential to alter the functioning of the program. It makes the building process easier to put in source control. 

In the field of development, a wide range of tasks doesn’t require actual visualisation. In such cases, all functions can be performed with the help of command-line arguments. There is a very rare requirement for a literal graphical interface. This helps save a lot of finances, effort, and resources.

 Learn Online software development courses from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Properties | Command Line Arguments in C  

Command-line arguments have quite a few interesting and useful properties. They are as follows:

  • To print the name of the program, the command has to be argv[0] 
  • argv[argc] is essentially a null pointer
  • To print the first argument that the user provides, the command has to be argv[1]
  • The user passes command-line arguments from the terminal
  • The use of these commands is to control the programs from the outside, instead of having to hard code the values inside the program
  • Command-line arguments are passed onto the main() function at all times
  • The first command land argument is argv[1], whereas the last command is argv[n]

Example of a Command-Line Argument

Following is a demo program for command line arguments in C:

// C program to illustrate

// command line arguments

#include<stdio.h>

int main(int argc,char* argv[])

{

int counter;

printf(“Program Name Is: %s”,argv[0]);

if(argc==1)

printf(“\nNo Extra Command Line Argument Passed Other Than Program Name”);

if(argc>=2)

{

printf(“\nNumber Of Arguments Passed: %d”,argc);

printf(“\n—-Following Are The Command Line Arguments Passed—-“);

for(counter=0;counter<argc;counter++)

printf(“\nargv[%d]: %s”,counter,argv[counter]);

}

return 0;

}

The output differs according to various scenarios. They have been further explained individually.

  1. Without an argument:

To produce the following output, the code has to be executed without passing an argument:

Output 1 – 

$ ./a.out

Program name is: ./a.out

No Extra Command Line Argument Passed Other Than Program Name

  • With three arguments:

To produce the following output, the code has to be executed with three arguments.

Output 2 –

$ ./a.out First Second Third

Program name is: ./a.out

Number of Arguments Passed: 4

—-Following Are The Command Line Arguments Passed—-

argv[0]: ./a.out

argv[1]: First

argv[2]: Second

argv[3]: Third

  • With a single argument:

The code needs to be compiled and executed with a single argument that has to be separated by space while being inside quotes to produce the following output.

Output 3 –

$ ./a.out “First Second Third.”

Program name is: ./a.out

Number of Arguments Passed: 2

—-Following Are The Command Line Arguments Passed—-

argv[0]: ./a.out

argv[1]: First Second Third

  • With a single argument in quotes and separated by space:

The code must be compiled and executed with a single argument separated by space but within single quotes to produce the following output.

Output 4 –

$ ./a.out ‘First Second Third’

Program name is: ./a.out

Number of Arguments Passed: 2

—-Following Are The Command Line Arguments Passed—-

argv[0]: ./a.out

argv[1]: First Second Third

Advantages of Command-Line Arguments in C

There are several benefits of using command line arguments in C. They are as follows:

  • Command-line arguments in C can be used when a programmer or user wants to pass the values to the program from the inside instead of doing so internally. 
  • The command-line applications can be very easily made to be used in batch files or scripts. This comes as a huge help where automated testing or builds are concerned.
  • The command line is easier to develop if programmers write the tools instead of using them. Inputting arguments are deemed to be a much more complex and time-consuming task than outputting a text stream.
  • The input, output, and error streams can be very easily redirected when information can be sent or received from various files and applications.
  • The error return mechanism in command-line arguments is quite standard and simple. 
  • When a programmer or user is trying to gain access from home or on the road, basically while being mobile, use over remote shells or other similar connections make it way easier to perform tasks in the least.
  • For the function of specifying multiple files, defined wildcard syntax standards are present, which draws from and banks upon the existing knowledge of the developer or programmer. 
  • Command lines are compelling and extremely fast. 

Talking of advantages in various command-line arguments, the following is another detailed example or demonstration of how you should implement them.

#include <stdio.h>

#include <conio.h>

//main method is called to which the command line arguments are passed to the program

int main(int argc, char *argv[])

{

//an integer variable is defined

int a;

//if the condition is applied to check if the count of arguments passed to the program is greater than or equal to two, and if the condition is true, the command line arguments passed to the program are printed. Otherwise, no argument is passed to the program is printed

if(argc >= 2)

{

printf(“The arguments passed to the program are:\n”);

for(a = 1; a < argc; a++)

{

printf(“The argument passed to the program is: %s\t”, argv[a]);

}

}

else

{

printf(“No argument is passed to the program\n”);

}

return 0;

}

Output:

No argument is passed to the program.

The command-line arguments are passed to the program in the code mentioned above by calling the main method. The next step is the definition of an integer variable. Next, the condition is passed to check if the count of arguments passed to the program is greater or equal to 2. The command-line arguments passed to the program are printed if the condition is true. If not, no argument is passed to the program and printed.

Conclusions

Learn more about the importance of command-line arguments in C and C++ by signing up for upGrad’s Executive PG Programme in Software Development – Specialisation in Full Stack Development. The 13-months course is designed to help aspiring IT professionals master Java, Spring, Hibernate, HTML, React, Git, and a range of other programming languages and tools to build complex applications like Quora and Swiggy. 

The program also offers a free 4-months Executive Certification in Data Science & Machine Learning.

What are the basic disadvantages that have to be faced by programmers while implementing command line arguments in C?

Even though command line arguments in C are convenient for developers and programmers, they do carry a few disadvantages. People who don’t have the basic knowledge and are not used to working with these commands may prove to be quite challenging to learn and adapt to, especially in a short period. However, this is not a problem for aced programmers and developers. But it proves to be a hindrance sometimes for junior employees who might come from different or adjacent fields. Moreover, command-line arguments need a keyboard to be implemented and executed. This often becomes a barrier if someone needs to access it through their phone or iPad, etc.

Which are the delimiters that are used to separate command-line arguments?

To separate command-line arguments, blank spaces are generally used. They separate the command name from its parameters and separate various parameters amongst each other. They also come in handy while separating a list of different values. Multi blanks are usually treated as a single blank. The only exception to this happens in a quoted string or a comment enclosed in single quotation marks.

Is it possible to convert command-line arguments?

All command-line arguments are passed on as a string. The numerical values must always be converted by programmers or users to their internal forms, using manual effort. The main function always receives its parameters, which usually is an array of strings. This is the only function argument that the main function accepts. String data types are made to be used while storing command line arguments.

Want to share this article?

Be a Master of Software Development

Leave a comment

Your email address will not be published. Required fields are marked *

Our Popular Software Engineering Courses

Get Free Consultation

Leave a comment

Your email address will not be published. Required fields are marked *

×
Let’s do it!
No, thanks.