Scribd
Upload
42 views4 pages

Processing Command-Line Arguments

The document discusses how command line arguments are processed in UNIX/POSIX systems and made available to C/C++ programs. When a program is executed, the shell parses the command line into words separated by whitespace. The first word is the program name, and subsequent words are command line arguments. These are passed to the main() function via its argc and argv parameters. argc specifies the number of words, and argv is an array of C strings containing the words. Proper usage requires checking argc to ensure the expected number of arguments were provided.

Uploaded by

abraham_sse1594
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
42 views4 pages

Processing Command-Line Arguments

The document discusses how command line arguments are processed in UNIX/POSIX systems and made available to C/C++ programs. When a program is executed, the shell parses the command line into words separated by whitespace. The first word is the program name, and subsequent words are command line arguments. These are passed to the main() function via its argc and argv parameters. argc specifies the number of words, and argv is an array of C strings containing the words. Proper usage requires checking argc to ensure the expected number of arguments were provided.

Uploaded by

abraham_sse1594
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

CSci 135 Software Analysis and Design I

Command Line Arguements

Stewart Weiss

Processing Command-Line Arguments


In a UNIX environment, when you type a command such as

g++ main.cpp utils.cpp fileio.cpp


or

rm file1 file2 file3 file4


and press the
characters. A

Enter

key, the shell program parses this command-line into words separated by whitespace

word is usually any sequence of non-whitespace characters1 . The rst word on the command

line, except in certain unusual commands, is the name of a program or a shell built-in command to be
run.

In the above examples, it is

called

g++

and

rm

respectively.

The words that follow the program name are

command-line arguments . In the rst example above, the command-line arguments are

utils.cpp,

and

fileio.cpp.

In the second example, they are

file1, file2, file3,

and

file4.

main.cpp,

In UNIX and in other POSIX-compliant operating systems, the operating system arranges for the program
name and the command-line arguments to be made available to the program itself via parameters to the

main()

function. Programs can ignore this information by writing the main function as

int main () { /* program here ... */ }


However, the C and C++ standards require compliant implementations of C and C++ to accept a

main()

with two parameters as follows:

int main ( int argc,

char * argv[]

) { /* program here ... */ }

The rst parameter is an integer specifying the number of words on the command-line, including the name
of the program, so

argc is always at least one.

The second parameter is an array of C strings that stores all

of the words from the command-line, including the name of the program, which is always in
command-line arguments, if they exist, are stored in
the

char*

argv[1], ..., up to argv[argc-1].

argv[0].

The

If you have not seen

type, refer to the notes on C strings and pointers on this website.

argc and argv; they can be


argc and argv, although you will
foo and bar but that would be pretty

Also note that there is nothing special about the names of two parameters
whatever names you want them to be. It is a convention to use the names
often nd programs that use

ac

and

av

instead. You can name them

bad programming style.


A simple C++ example that illustrates how a program can access the command-line arguments is below.
This simple program does nothing more than display the name that the user typed to execute the program,
followed by the command-line arguments that it received from the shell.

# include < iostream >


using namespace std ;
int main ( int argc , char * argv [])
{
1 Certain

symbols such as the shell redirection operators, semicolons, quotes, and so on, are not considered words in this

sense.

CSci 135 Software Analysis and Design I


Command Line Arguements

Stewart Weiss

cout << argv [0] << " : " ;


for ( int i = 1; i < argc ; i ++ ){
cout << argv [ i ] << " " ;
}
cout << endl ;
return 0;

Whenever you write a program that expects command-line arguments you must check whether the expected
number of arguments was provided by the user. Otherwise, the program will attempt to access locations in
the array of arguments that do not exist.
For example, suppose that you write a program that expects the names of two les on the command-line,
the rst being the name of a le to open for reading and the second being the name of a le to open for
writing. Suppose that the name you give to the program executable is

myprog.

Then proper use of

myprog

would be something like

myprog inputfile outputfile


There have to be at least three words on the command-line for your program to run properly. There might
be more, but it can ignore those words. Therefore, the program should only run if the rst parameter to

main()

is at least 3. The program must therefore begin with

int main ( int argc , char * argv []


{
/* declarations here */

if ( argc < 3 ) {
/* handle the incorrect usage here */
cerr << usage : << argv [0] << " i n p u t F i l e N a m e
exit (1);
}
/* rest of program */

outputFileName \n";

If the user did supply the correct number of arguments, then it is safe for the program to access the strings
from the second parameter. The program might look something like

int main ( int argc ,


{
ifstream fin ;
ofstream fout ;

char * argv []

if ( argc < 3 ) {
/* handle the incorrect usage here */
cerr << usage : << argv [0] << " i n p u t F i l e N a m e
exit (1);
}
fin . open ( argv [1]);
if ( fin . fail () ) /* handle the error here */

fout . open ( argv [2]);


if ( fout . fail () ) /* handle the error here */
/* rest of program */

outputFileName \n";

CSci 135 Software Analysis and Design I


Command Line Arguements

Stewart Weiss

A Renement
If the user types a command such as

../../proj1/testcode/myprog infile
and forgot to include the output le, the above code would produce output such as

usage:

../../proj1/testcode/myprog inputFileName

outputFileName

If you do not want to display the entire path name of the program, but prefer that it only displays

usage:

myprog inputFileName

outputFileName

then you have to strip o the leading part of the

argv[0]

string so that the only thing left is what comes

after the nal '/' character. The C string library has a function that will make this easy, provided you are
familiar with pointers.
You can use the

strrchr()

function, whose prototype is

char *strrchr(const char *source, int ch);


This function nds the last occurrence in the string
it returns a

NULL

source of the character ch.

If

ch is not in source, then

pointer. Therefore a strategy for displaying the characters of the program name after the

nal '/' is to check whether it has a slash, and if it does, display the part after it. The simplest way to do
this is to take advantage of the fact that the program is allowed to modify the
it can change what

argv[0]

argv[]

array. In particular,

points to. The following C++ program does just this.

# include < iostream >


# include < cstring >
using namespace std ;
int main ( int argc , char * argv [])
{
char * forwardslashptr ;
forwardslashptr = strrchr ( argv [0] , ' / ' );
if ( forwardslashptr != NULL )
/* argv [0] does contain the '/ ' , so reset it so it points to
the character just past the '/ ' character . Nothing needs
to be done if it has no slash .
*/
argv [0] = forwardslashptr +1;
cout << argv [0] << " : " ;
for ( int i = 1; i < argc ; i ++ ){
cout << argv [ i ] << " " ;
}
cout << endl ;
return 0;
}
This program uses pointer arithmetic. The line
3

CSci 135 Software Analysis and Design I


Command Line Arguements

Stewart Weiss

argv[0] = forwardslashptr+1;
sets the

argv[0]

string, which is, remember, a pointer to an array of characters, to the value obtained by

adding one to the address stored in

forwardslashptr.

The compiler translates pointer addition to add

however many bytes are needed by the type of thing that the pointer points to. In other words, if a pointer
points to a

char

and a

char

takes up one byte, it adds 1. Therefore the above instruction causes

to point to the rst character after the slash.

argv[0]

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy