Htydjtk

Why is argv declared as "a pointer to pointer to the first index of the array", rather than just being "a pointer to the first index of array" (char* argv), why is the notion of "pointer to pointer" required here?

Argv is basically like this:

So on the left is the argument itself--what's actually passed as a parameter to main. That contains the address of an array of pointers. Each of those points to some place in memory containing the text of the corresponding argument that was passed on the command line. Then, at the end of that array there's guaranteed to be a null pointer.

Note that the actual storage for the individual arguments are at least potentially allocated separately from each other, so their addresses in memory might be arranged fairly randomly (but depending on how things happen to be written, they could also be in a single contiguous block of memory--you simply don't know or and shouldn't care).

Because that's what the operating system provides :-)

Your question is a little bit of a chicken/egg inversion issue. The problem is not to choose what you want in C++, the problem is how you say in C++ what the OS is giving you.

Unix passes an array of "strings", each string being a command argument. In C/C++, a string is a "char*", so an array of strings is char* argv, or char** argv, according to taste.

First, as a parameter declaration, char **argv is the same as char *argv; they both imply a pointer to (an array or set of one or more possible) pointer(s) to strings.

Next, if you only have "pointer to char" (e.g. just char *, then in order to access the nth item, you'll have to scan the first n-1 items to find the nth item's start.  (And this would also impose the requirement that each of the strings are stored contiguously.)

With the array of pointers, you can directly index the nth item — so (while not strictly necessary — assuming the strings are contiguous) it is generally much more convenient.

To illustrate:

./program hello world

argc = 3

argv[0] --> "./program"

argv[1] --> "hello"

argv[2] --> "world"

It is possible that, in string:
"./programhelloworld"
argv[0] ^
argv[1] ^
argv[2] ^

if argv were just a "pointer to char" you might see

       "./programhelloworld"

argv    ^

However (though likely by design of the os) there is no real guarantee that the three strings "./program", "hello", and "world" are contiguous.  Further, this kind of "single pointer to multiple contiguous strings" is a more unusual data type construct (for C), especially compared with array of pointers to string.

Rather than thinking of it as "pointer to pointer", it helps to think of it as "array of strings", with denoting array and char* denoting string. When you run a program, you can pass it one or more command-line arguments and these are reflected in the arguments to main: argc is the count of arguments and argv lets you access individual arguments.