Forgive the somewhat simple question I am sure this will be, but I am
having some problem understanding what:  char **argv looks like.  For
instance, i know through trial and error that if I do this:

#include <stdio.h>

int main(int argc, char *argv[])
{
        int l;
        for( l=0; l<argc; l++ )
        {
                printf("Pointer: %p\tValue: %s\n", argv++, *argv);
        }

        return 0;

./foo one two three

Then I will see:

0x10202 foo
0x10204 one
0x10208 two
ox1020c three

Listed, but I would have expected to have needed to write:

*(*(argv))

So as to dereference what the pointer that *argv pointed to.  Or have
I missed the point?

Thanks.

  printf("Pointer: %p\tValue: %s\n", (void *)argv, *argv);
  ++argv;

<snip>

  printf("Pointer: %p\tValue: %s\tFirst: %c\n",
         (void *)argv,
         *argv,
         **argv);
  ++argv;

     `argv' is a pointer to a pointer to a char, which I'll
write as "pointer to [pointer to char]" for emphasis.

     Applying `*' to a pointer accesses the thing the pointer
points to.  So `*argv' is a "[pointer to char]", the thing
that `argv' itself points at.

     Now we apply `*' again, this time to the "[pointer to
char]" we got from the first step.  `**argv' (which is the
same a `*(*argv))') is therefore a char, the first char of
one of the argument strings.

     Another thing you can do to gain facility in understanding
multiple levels of pointers is to draw a picture:

        char**    char*'s        char's

        argv ---> argv[0] ---> { 'f', 'o', 'o', '\0' }
                  argv[1] ---> { 'o', 'n', 'e', '\0' }
                  argv[2] ---> { 't', 'w', 'o', '\0' }
                  argv[3] ---> { 't', 'h', 'r', 'e', 'e', '\0' }
                  argv[4] == NULL

1. The parens are not needed. 'char **argv' is what it is, a pointer to
a pointer to char.

2. In your printf statement above you have both argv++ and *argv.
Because we have no way to know which expression might be evaluated
first, this is classic Undefined Behavior.

#include <stdio.h>

int main(int argc, char **argv)
{
    int l;
    for (l = 0; l < argc; l++) {
       printf("Pointer: %p\tValue: %s\n", argv, *argv);
       argv++;
    }
    return 0;

On 5 Jul, 22:34, Eric Sosman <esos...@ieee-dot-org.invalid> wrote:

I suppose understand conceptually how type_t **foo works -- i do have
to ask *why* the command-line options to a program is in the form:

char **foo

As opposed to a singular array of chars, i,e,:

char foo[SOME_MAX_VALUE]

My guess is:  char **foo defers the decision to decide how big the
array might be at runtime, but I could be wrong.

Thanks once again for everyone's patience -- I know this is heavy
going.

<snip>

q1) why is it char* and not char[SOME_MAX_VALUE] ?

a1) It allows implementors to only use the minimum required or to use
some maximum value if they prefer.  The downside is that the user
programmer cannot rely on being able to write past the end of the string,
but that's not a problem because he can define his own MAX_VALUE and
create his own automatic array if he needs it.

q2) Why is it char** and not char* ?

a2) Because that would greatly limit the power of shells, and it would
require every application to perform its own command line interpreting
(eg: working out that 'some string' is one argument without the quotes).

As an aside, on many implementations there is no specific limit on the
length of any one argument, but the total of all of them is limited.  
Here IIRC that limit is 32kiB.

type_t foo[BAR];

Then BAR could still be evaluated at run-time -- much like argc is to
main() surely?  So again:  Why the need for multiple indirection -- I
am not saying you're wrong, I am just curious why we have it for
command-line options in this case, and perhaps where other use of:
type_t **foo come into play.

Thanks!

        int main(int argc, tstring argv[])

where argv is an array of tstring.

But ... strings in C are represented by char *.

=============
#include <stdio.h>
typedef char * tstring;
int main(int argc, tstring argv[]) {
  int n;
  for (n=0; n<argc; n++) {
    printf("arg %d is \"%s\".\n", n, argv[n]);
  }
  return 0;

printf() with the "%s" format expects an argument of type char*,
which must point to the first character of a string.  printf itself
will dereference this char* pointer to extract and print the
characters of the string.

Incidentally, "%p" is the correct format for printing a pointer
value, but it expects an argument of type void*.  If you want to
print a pointer of some other type, you should cast it to void*.

Finally, some style points (oh, here goes Keith with his "style
points" again).

"l" isn't a great name for a variable; it looks too much like the
digit 1 (and can be indistinguishable in some fonts).

Some would argue that modifying a function argument is poor style.
I don't agree, but modifying argv while leaving argc alone is odd.
An idiom I've seen for traversing command-line arguments is to
increment argv while decrementing argc.  Or you can just use an
integer to loop through the arguments, leaving argc and argv alone.
(If you're concerned that indexing will be slower than stepping
through with a pointer, don't be; the difference will be minimal,
and a good optimizing compiler will likely generate the same code
either way.)

Of course none of this is a big deal for a program this small, but
small programs are where you should start to develop good habits.