[SOLVED] CS OSU CSE 2421

OSU CSE 2421
Recommended Reading: Pointers On C, Chapter 13, Sections 13.4 through 13.4.2
J.E.Jones

OSU CSE 2421
We know that, when we call a function in a C program, arguments can be passed to the function.
When we execute a C program from the command line, we can also pass arguments to main().
Lets see how this is done.
J. E. Jones

OSU CSE 2421
main() is invoked when we run a command on the command line to execute a C program. For example, for a program called myProg:
% myProg
If we want to pass arguments, or parameters, say p1, p2, and p3, to main() in myProg, we enter them on the command line after the name of the program:
% myProg p1 p2 p3
then, well declare main with parameters so we can access them
J. E. Jones

OSU CSE 2421
Any arguments passed from the command line will be placed in read-only memory.
Remember string-literals are put there, too
If we want to pass arguments to main() from the command line, we have two appropriate declarations of the parameters for main() inside the program:
int main(int argc, char **argv) { } int main(int argc, char *argv[]) { }
One of these approaches uses a pointer to a pointer to char for the 2nd parameter and the other uses an array of char pointers.
These two declarations are equivalent (they are just different ways of looking at the same thing more explanation below).
J. E. Jones

OSU CSE 2421
The parameters given on the command line are passed to a C program using two variables, which have the following names, by convention:
1. argc contains the count of the command line arguments. Think argcount or argument count
2. argv contains pointers to the individual arguments as character strings (argv[] is an array of char *). Think argvector or argument vector.
A conclusion you might make (and youd be right) is that, since argv points to individual arguments as character strings, ALL command line arguments enter a C program as ASCII strings!
In the declaration of main(), the names of argc and argv may be any valid identifiers in C, but it is a common convention to use these names.
NOTE!!: There is no guarantee that the strings pointed to by the pointers in argv are stored in contiguous locations in memory, as they would be in a normal array, because argv is an array of pointers to these strings!
J. E. Jones

OSU CSE 2421
Again, suppose that, at the command line prompt, we enter: % myProg 16 new old
This results in argc containing the value 4 and the following strings to which the elements of argv point, because argv[] is an array of char * (or a char **):
argv[0] points to myProg /*string with program name */ argv[1] points to 16
argv[2] points to new
argv[3] points to old
argv[4] is a NULL pointer
Note that, because these strings are of type char *, they are stored in read only
memory, and any attempt to write to them will result in a segmentation fault!
Also note that each argument is an ASCII string terminated by a NULL byte ().
J. E. Jones

OSU CSE 2421
Consider: argv->
0x800540->myProg
0x800540 0x8012A0 0x800260 0x80200C 0x000000
540 541 542 543 544
545 546
argc = 4
Note: each individual string is in continuous memory locations, but each string can be in various locations
m y P r o
g
0x8012A0->16
2A0 2A1 2A2
1 6
0x800260->new
260 261 262 263
n e w
0x80200C->old
00C 00D 00E 00F
o l d
J. E. Jones

OSU CSE 2421
Recall that any array may be viewed as a (constant) pointer to the first element of the array.
For this reason, argv can be declared in one of two ways: int main(int argc, char *argv[]);
int main(int argc, char **argv);
Thus, argv may be viewed as an array of char *, or as a char ** (a pointer to a pointer to char).
Which way you choose to declare it in your programs is up to you. Pick the way that is easier for you to visualize your data.
J. E. Jones

OSU CSE 2421
After the arguments are passed to main(), we can access them, just as any other function parameters:
#include
int main(int argc, char *argv[]) {
}
printf(argv[%i]t= %s
, i, argv[i]); return (0);
int i;
printf(argc =t%d
, argc); for (i = 0; i < argc; i++)OR int main(int argc, char **argv) { char **ip = argv;Notice first version uses argc to loop, the second uses the fact that argv[argc]==NULL}printf(argv[%i]t= %s
, i++, *ip++); return (0);int i=0;printf(argc =t%d
, argc); while(*ip!= NULL)J. E. Jones OSU CSE 2421 For the command line input: myProg 16 new old The programs on the previous slide both print: argc = 4argv[0] = myProgargv[1] = 16argv[2] = new argv[3] = oldJ. E. Jones OSU CSE 2421 The name of the program, argv[0], can be useful when printing diagnostic or error messages. Usually, multiple processes (or programs) are running on the system, so it is useful to be able to identify which process caused an error.printf(myProg expects 3 parameters, only %d were entered
, argc-1);or a better way…printf(%s expects 3 parameters, only %d were entered
, argv[0], argc-1);The second option allows for the myProg executable to be copied to another filename. (e.g. cp myProg sumProg). If we use the 2nd option when using the program with its new name (sumProg), the error message is still correct. The values of the other parameters can be accessed and used just as any other function parameters.J. E. Jones OSU CSE 2421 It is guaranteed that argc is non-negative, and that argv[argc] is a NULL pointer. By convention, the command line arguments specified by argc and argv include the program name as the string that is pointed to by argv[0]. For example, if a user types the command rm file, the shell will initialize the rm process with argc = 2, argv[0] as rm, and argv[1] as file, and argv[2] as 0 [the value of a NULL pointer]. Remember that the main() function is special. Every C program must define it exactly once.J. E. Jones OSU CSE 2421 /* sum.c sum n1 n2 n3… =>n1+n2+
** This program sums the integer values that correspond to the ** strings from argv[1] to argv[argc 1] */
#include
int main(int argc, char *argv[]){
int i;
int sum = 0;
for (i = 1; i < argc; i++){sum = sum + ( atoi (argv[i]) ); /* atoi() converts an ASCII string to an int */ }printf(The sum of the command line arguments after the first is %i.
, sum);return (0); }Why do we need to use the atoi() function???J. E. Jones OSU CSE 2421 /* sum.c** This program sums the integer values that correspond to the ** strings from argv[1] to argv[argc 1] */#include
int main(int argc, char *argv[]){
int i;
int sum = 0;
for (i = 1; i < argc; i++){sum = sum + ( atoi (argv[i]) ); /* atoi() converts an ASCII string to an int */ }printf(The sum of the command line arguments after the first is %i.
, sum); return (0);}Why do we need to use the atoi() function??? ALL parameters are ASCII strings!!J. E. Jones OSU CSE 2421 int atoi() convert ASCII string to 4-byte integer data type long atol() convert ASCII string to 8-byte integer data type long long atoll() convert ASCII string to 16-byte integer data type (C99 and above) double atof() convert ASCII string to 8-byte floating point data type float f = (float)atof(); if you want a 4-byte floating point data typeJ. E. Jones OSU CSE 2421 Now, after compiling the program, suppose we enter on the command line:% sum 100 50 25 The program prints out:The sum of the command line arguments after the first is 175.J. E. Jones