Here's how I would put it. Much of this you probably already know.

If you declare int n = 4;, then the compiler reserves a special location to store an int value, and stores 4 there. No big deal. The location for n is an address, some big number the program uses to keep track of where that n variable is located. We cannot change the address of n, so that's an important point. And we normally don't need to know the value of the address. The address value for n might change each time the program runs.

If you declare int *n_ptr = &n;, then the compiler reserves a special location to store a pointer value, and stores the address of n there. n and n_ptr are both variables. Again, n_ptr has an address, some big number used to keep track of where it is. Again, we cannot change the address of n_ptr. Of course, *n_ptr is the contents of the n var, so 4 in this case.

The difference between n and n_ptr is that the program "knows" (because it reads the declaration) that n holds an int, and that n_ptr holds the address of an int variable.

Another difference is that n++ results in adding one (like 4 -> 5), but n_ptr++ results in adding something like four or eight (like 1000000 -> 1000004) to move the address to the next slot that can hold an int. If the size of an int is four bytes, then n_ptr++ increases n_ptr by 4 (not 1).

&n and &n_ptr both make sense. You can take an address of either variable. You could do int **n_pp = &n_ptr;

But only *n_ptr makes sense (would equal 4). *n makes no sense, does not compile, because the n variable does not point to anything else. You can only dereference (with *) a pointer variable, or an array.

Inside the running program, a pointer (like char *ptr_var; and array (like char array_var[10];) are treated the same in many ways, but are different things.

Some similarities: &ptr_var and &array_var both work and produce the same result. *ptr_var, *array_var, ptr_var[0], array_var[0] all work and produce the same result.

A difference: ptr_var++ works, and increases the stored value. But array_var++ does not work, because it will try to increase the address of array_var and this does not make sense, is not allowed. Just like we cannot change the address of the n variable, we cannot change the address of the array_var. You could say array_var[0]++ and that's OK.

--------------------------------

I would say the pointer has an address and also holds an address.

I would say argv was looped through in both cases, but just a different way, either by increasing iCount or by increasing the address held in the argv variable.

Yes, *argv[iCount] is only the first char of the contents, and is exactly the same as argv[iCount][0]

----------------------------

This stuff is confusing for many or most C programmers. But it's very interesting and really important for effective programming. As you are doing, one good way to learn is to write little test programs, and see what happens.