What is the type of command-line argument `argv` in C?

Question

I'm reading a section from C Primer Plus about command-line argument argv and I'm having difficulty understanding this sentence.

It says that,

The program stores the command line strings in memory and stores the address of each string in an array of pointers. The address of this array is stored in the second argument. By convention, this pointer to pointers is called argv, for argument values .

Does this mean that the command line strings are stored in memory as an array of pointers to array of char?

Answer 1

argv is of type char **. It is not an array. It is a pointer to pointer to char. Command line arguments are stored in the memory and the address of each of the memory location is stored in an array. This array is an array of pointers to char. argv points to first element of this array.

                  Some
                  array

                 +-------+        +------+------+-------------+------+
argv ----------> |       |        |      |      |             |      |
                 | 0x100 +------> |      |      | . . . . . . |      |  Program Name1
         0x900   |       |        |      |      |             |      |
                 |       |        +------+------+-------------+------+
                 +-------+         0x100  0x101
                 |       |        +------+------+-------------+------+
                 | 0x205 |        |      |      |             |      |
         0x904   |       +------> |      |      | . . . . . . |      |  Arg1
                 |       |  .     |      |      |             |      |
                 +-------+        +------+------+-------------+------+
                 |  .    |  .      0x205  0x206
                 |  .    |
                 |  .    |  .
                 |  .    |
                 +-------+  .     +------+------+-------------+------+
                 |       |        |      |      |             |      |
                 | 0x501 +------> |      |      | . . . . . . |      |  Argargc-1
                 |       |        |      |      |             |      |
                 +-------+        +------+------+-------------+------+
                 |       |         0x501  0x502
                 | NULL  |
                 |       |
                 +-------+


0xXXX Represents memory address

---

_{1. In most of the cases argv[0] represents the program name but if program name is not available from the host environment then argv[0][0] represents null character.}

Answer 2

Directly quoting from C11, chapter §5.1.2.2.1/p2, program startup, (emphasis mine)

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

[...] If the value of argc is greater than zero, the array members argv[0] through argv[argc-1] inclusive shall contain pointers to strings, [...]

and

[...] and the strings pointed to by the argv array [...]

So, basically, argv is a pointer to the first element of an array of strings ^note. This can be made clearer from the alternative form,

int main(int argc, char **argv) { /* ... */ }

You can rephrase that as pointer to the first element of an array of pointers to the first element of null-terminated char arrays, but I'd prefer to stick to strings .

---

NOTE:

To clarify the usage of "pointer to the first element of an array" in above answer, following §6.3.2.1/p3

Except when it is the operand of the sizeof operator, the _Alignof operator, or the unary & operator, or is a string literal used to initialize an array, an expression that has type ‘‘array of type’’ is converted to an expression with type ‘‘pointer to type’’ that points to the initial element of the array object and is not an lvalue. [...]

Answer 3

This thread is such a train wreck. Here is the situation:

• There is an array with argc+1 elements of type char *.
• argv points to the first element of that array.
• There are argc other arrays of type char and various lengths, containing null terminated strings representing the commandline arguments.
• The elements of the array of pointers each point to the first character of one of the arrays of char; except for the last element of the array of pointers, which is a null pointer.

Sometimes people write "pointer to array of X" to mean "pointer to the first element of an array of X". You have to use the contexts and types to work out whether or not they actually did mean that.

Answer 4

Yes, exactly.

argv is a char** or char*[], or simply an array of char* pointers.

So argv[0] is a char* (a string) and argv[0][0] is a char.

Answer 5

Yes.

The type of argv is char**, i.e. a pointer to pointer to char. Basically, if you consider a char* to be a string, then argv is a pointer to an array of strings.

Answer 6

Strictly speaking, there are a number of properties that must be present for argv to be an array. Let us consider some of those:

¹/ There can be no array pointed at by a null pointer, as null pointer are guaranteed to be an address distinct from that of any object. Therefore, argv in the following code can't be an array:

#include <assert.h>
int main(int argc, char *argv[]) {
    if (argv) return main(0, 0);
    assert(argv == 0); // argv is a null pointer, not to be dereferenced
}

²/ It's invalid to assign to an array. For example, char *argv[] = { 0 }; argv++; is a constraint violation, but int main(int argc, char *argv[]) { argv++; } compiles and runs fine. Thus we must conclude from this point that argv is not an array when declared as an argument, and is instead a pointer that (might) point into an array. (This is actually the same as point 1, but coming from a different angle, as calling main with a null pointer as argv is actually reassigning argv, something we can't do to arrays).

³/ ... As the C standard says:

Another use of the sizeof operator is to compute the number of elements in an array: sizeof array / sizeof array[0]

For example:

#include <assert.h>
int main(int argc, char *argv[]) {
    size_t size = argc+1; // including the NULL
    char *control[size];
    assert(sizeof control / sizeof *control == size); // this test passes, because control is actually an array
    assert(sizeof argv   / sizeof *argv    == size); // this test fails for all values of size != 1, indicating that argv isn't an array
}

⁴/ The unary &address-of operator is defined such that when applied to an array, will yield the same value of a different type, so, for example:

#include <assert.h>
int main(int argc, char *argv[]) {
    char *control[42];
    assert((void *) control == (void *) &control); // this test passes, because control is actually an array
    assert((void *) argv    == (void *) &argv); // this test fails, indicating that argv isn't an array
}

Answer 7

argv is an array of pointers to characters.

The following code displays the value of argv, the contents of argv and performs a memory dump on the memory pointed at by the contents of argv. Hopefully this illuminates the meaning of the indirection.

#include <stdio.h>
#include <stdarg.h>

print_memory(char * print_me)
{
    char * p;
    for (p = print_me; *p != '\0'; ++p)
    {
        printf ("%p: %c\n", p, *p);
    }

    // Print the '\0' for good measure
    printf ("%p: %c\n", p, *p);

}

int main (int argc, char ** argv) {
    int i;

    // Print argv
    printf ("argv: %p\n", argv);
    printf ("\n");

    // Print the values of argv
    for (i = 0; i < argc; ++i)
    {
        printf ("argv[%d]: %p\n", i, argv[i]);
    }
    // Print the NULL for good measure
    printf ("argv[%d]: %p\n", i, argv[i]);
    printf ("\n");

    // Print the values of the memory pointed at by argv
    for (i = 0; i < argc; ++i)
    {
        print_memory(argv[i]);
    }

    return 0;
}

Sample Run:

$ ./a.out Hello World!
argv: ffbfefd4

argv[0]: ffbff12c
argv[1]: ffbff134
argv[2]: ffbff13a
argv[3]: 0

ffbff12c: .
ffbff12d: /
ffbff12e: a
ffbff12f: .
ffbff130: o
ffbff131: u
ffbff132: t
ffbff133:
ffbff134: H
ffbff135: e
ffbff136: l
ffbff137: l
ffbff138: o
ffbff139:
ffbff13a: W
ffbff13b: o
ffbff13c: r
ffbff13d: l
ffbff13e: d
ffbff13f: !
ffbff140:

$

You have this big contiguous array ranging from ffbff12c to ffbff140 which contains the command line arguments (this is not guaranteed to be a contiguous by the standard, but is how it's generally done). argv just contains pointers into that array so you know where to look for the words.

argv is a pointer... to pointers... to characters