I am looking at a unique example here and am trying to understand why his snippet behaves the way it does
// uninitialized mem char test[99999]; // test[0] = 'a'; test[1] = 'b'; test[2] = 'c'; test[3] = 'd'; test[4] = 'e'; test[5] = 'f'; test[6] = 'g'; for (int i = 0; i < 99999; i++) { cout << (&test[i])[i] << endl; } In particular, what is happening in memory for the output to skip a character?
output: a c e g .. This is what is happening: An array is just a contiguous chunk of memory.
&test Is getting the address of that index of the starting point of array. Not the value.
When you add [some number], it counts up the number times the size of the data type, in this case each char is a byte.
So when you do
&test[i] that means the starting address + i bytes.
when you do
(&test[i])[i] You are doing i bytes from the starting address, and then treat that as the starting address and go up i more bytes.
So in your iterations:
(&test[0])[0] // index 0 + 0 = 0 (&test[1])[1] // index 1 + 1 = 2 (&test[2])[2] // index 2 + 2 = 4 (&test[3])[3] // index 3 + 3 = 6 
It should become a bit more obvious when you consider what the array indexing is actually doing.
Given an array test, you usually access the nth element of test with test[n]. However, this is actually the equivalent of *(test+n). This is because addition on pointers automatically multiplies the amount you add with the size of the type being pointed to. This means the pointer will then be pointing at the second item in the array if you add one to the pointer, the third item if you add two, and so on.
The code you provide then references that value, so you end up with &(*(test+n)). The reference (&) and the dereference (*) operations then cancel each other out, which means you end up with just test+n.
The code then does another array index on that value, so you end up with (test+n)[n], which again may be written as *((test+n)+n). If you simplify that, you get *(test+n+n), which may be rewritten as *(test+2*n).
Clearly then, if you convert that back to array indexing notation, you end up with test[2*n], which indicates in simple form that you'll be querying every other element of the array.
&is an address-of operator here.