Question: I think I understand references and pointers pretty well. Here is what I (think I) know:

```
int i = 5; //i is a primitive type, the value is 5, i do not know the address.
int *ptr;  //a pointer to an int. i have no way if knowing the value yet.
ptr = &i;  //now i have an address for the value of i (called ptr)
*ptr = 10; //Go to the value in ptr, use it to find a location and store 10 there

```

Please feel free to comment or correct these statements.

Now I'm trying to make the jump to arrays of pointers. Here is what I do not know:

```
char **char_ptrs = new char *[50];
Node **node_ptrs = new Node *[50];

```

My understanding is that I have 2 arrays of pointers, one set of pointers to chars and one to nodes. So if I wanted to set the values, I would do something like this:

```
char_ptrs[0] = new char[20];
node_ptrs[0] = new Node;

```

Now I have a pointer, in the 0 position of my array, in each respective array. Again, feel free to comment here if I'm confused.

So, what does the \*\* operator do? Likewise, what is putting a single \* next to the instantiation doing (\*[50])? (what is that called exactly, instantiation?)

Answer: 
`**` is just `*` twice, so a pointer to a pointer.

When put next to a type, `*` binds left, not right. Saying `new char *[50]` is actually `new char* [50]` and instantiates an array of 50 `char*`.
Clarifying the first section:

```
int i = 5; // i is a primitive type, the value is 5, the address is retrieved via &i.
int *ptr;  // an unassigned pointer to an int
ptr = &i;  // ptr now point to the address of variable i
*ptr = 10; // access (dereference) the value through ptr and change it to 10 (same as i=10)

```

There is no \*\* operator, just \* operator. Like the others have said, \*\* declares a pointer to a pointer. Because you are declaring arrays of pointers, and pointers are declared with the \* operator, you need to declare them as such when allocating memory for them with `new`. Hence, you have:

```
char **char_ptrs = new char *[50]; // allocates memory for 50 contiguous char* (pointers)
Node **node_ptrs = new Node *[50]; // allocates memory for 50 contiguous Node* (pointers)

```

Pointers to pointers do not necessarily have to declare arrays. You can just as well have a regular pointer pointed to by another pointer, as in:

```
char i = 'p';
char *myptr = &i;
char **mysecondptr = &myptr;

```