C while loop calling ++ against itself when is a char

Question

I found this function and I don't understand certain parts of it. I have about 3 days worth of C experience, so bear with me. This function serves a purpose of parsing command-line arguments.

1. Why do they reassign *arg to *c ?

2. I don't understand why they are running a while loop.

3. Secondly, why would they run a while loop against a char pointer? I understand that a char is actually an array of characters, but my understanding is that they would only run a while loop against a char is to access the array character values individually, and they don't do any of that.

4. How can you increment against a char?

5. Why do we even have *c?

6. I added the string check to see if the arg is -styles for example, which has a - so I can parse the flag and obtain the value, which is the next arg in argv — is that correctly used?

Like I said, I've got about 3 days of C experience, so please be thorough and methodical and as helpful as possible as to help me better understand this function and C overall.

void print_args(int argc,char *argv[])
{
     int i;
     if(argc > 1){
       for(i=1;i<argc;i++){
           char *arg = argv[i];
           char *c = arg;
           while(*c){
             if(strchr("-", *c)){
                 printf("arg %d: %s -> %s\n",i,arg,argv[i+1]);
             }  
             c++;
         }
       }
     }
 }

Answer 1

1) arg is assigned to point to the head of the current char array, and c is used to traverse the array.

2,3,5) The while loop is run until c points to (char)0, which incidently is also \0. So in effect they go over every character in the char array, until they reach the null terminator symbol. A better conditional would have been while (*c != '\0'), rather than relying implicitly that '\0' == 0

4) They increment a pointer, Thus having it point to the next memory cell, i.e. the next array cell.

6) Your addition will work as a test to recognise an option, you'd still have to compare it against -styles to see that it is indeed a valid option.

This code sample could do with a lot of fixing up to make it more robust and clearer. If this is from a book or C tutorial, I suggest you look for another.

Answer 2

Most of the individual things that code does could make sense alone, but that while loop over the characters in arg is bizarre. It's something like "print arg and next arg for every dash in arg". But I doubt anyone really wants that.

Answer 3

I turned print_args into the main function of a program that contains nothing else and ran it. This is what it does:

$ ./a.out a ab abc abcd
arg 1: a -> ab
arg 2: ab -> abc
arg 2: ab -> abc
arg 3: abc -> abcd
arg 3: abc -> abcd
arg 3: abc -> abcd
arg 4: abcd -> (null)
arg 4: abcd -> (null)
arg 4: abcd -> (null)
arg 4: abcd -> (null)

In other words, for each character of each command line argument, it prints that entire command line argument, a thin arrow, and the next command line argument. (If my C library wasn't nice about printf("%s", (char *)NULL), it would crash when it got to the end.) Printing the entire command line argument is why it needs both c and arg, although that line perfectly well could have read

printf("arg %d: %s -> %s\n", i, argv[i], argv[i+1]);

and then arg would be unnecessary.

Your guess is as good as mine as to why this function does this particular thing. To me it does not seem like a particularly useful thing to do.

EDIT: If your goal is to print argv[i] and argv[i+1] whenever argv[i] starts with a dash and argv[i+1] is not NULL (which is a thing that might actually make sense in context), then you should write it like so:

void
print_args(int argc, const char *const *argv)
{
    int i;
    for (i = 0; i < argc; i++)
        if (argv[i][0] == '-' && argv[i+1])
            printf("arg %d: %s -> %s\n", i, argv[i], argv[i+1]);
}

If you want to print whenever argv[i] contains a dash, then replace

argv[i][0] == '-'

with

strchr(argv[i], '-')

in the if statement.

Addendum: I strongly recommend you read http://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html which describes how modern UNIX command line programs are supposed to interpret their arguments.

Answer 4

When you increment a pointer, you're going to the next address after that pointer. So let's say you're at address 0000, the next one is 0004, 0008, etc. The value at that address could be, for instance, a character in the string. So if the string is "hello", then *c would be "h", and the first *c++ would be "e".

while loops are usually not the most efficient ways to do things, because you can easily get stuck in an infinite loop. It is to ensure that every character in the string has been accounted for.

I'm not totally sure why they assign arg to *c.