Accessing Array Elements

The Value of an Array Variable

Say we make an array:

float myArr[3]{1.2, 3.4, 5.6};

Here is what that array would look like in memory:

We can see the values of the floats in the array. But the variable we just created is named myArr.

What is the value of myArr?

Key ideas:

• When we ask for the “value” of an array variable, we get its memory address.
• Specifically, the memory address of the first item in the array.
  • In general, the memory address of something that takes up multiple slots will be the first address in the thing.
• So in our example, using our memory model, trying to get the value of myArr gives us its address on the stack: S1.

Consider the following code snippet:

int main() {
    float num = 3.14;
    int a[5]{11, 22, 33, 44, 55};
    return 0;
}

Accessing the Value at an Address

C++ gives us the ability to get the value at a given memory address!

If you type *x, you're saying “the value at the memory address x”.

The * is called the indirection operator. Because when we have an address, we don't have the thing itself (we don't have it directly); instead we have something that tells us where it is (so it gives us the thing indirectly). The * operator gives us the actual thing in that piece of memory.

So, in this example, x is like a treasure map, and *x is the treasure.

So, back to our original example:

float myArr[3]{1.2, 3.4, 5.6};
cout << *myArr << endl;

What gets printed?

Hints:

• Remember, we decided that the value of myArr is S1.
• You might want to refer back to our memory diagram above!

If we have

float myArr[3]{1.2, 3.4, 5.6};
*myArr = 7.8;

then the memory diagram looks like

Assigning a value to *myArr is the same as assigning a value to the first float in the array!

The Name of an Array Item

Though it's not literally a variable name (it's an operator applied to a variable), *myArr is, for all intents and purposes, a name for the first item in the array. We can get its value and we can assign a value to it.

So, on our diagram, we'll just write *myArr next to the first item as its name! Anytime we say *myArr in our code, we are talking about that item in the array.

Recall this code snippet:

int main() {
    float num = 3.14;
    int a[5]{11, 22, 33, 44, 55};
    return 0;
}

Accessing Other Items

If x stores a memory address, then *x is the value at that memory address.

We can also get memory addresses at offsets from x. Specifically, x + 1 is also a memory address. It's the "next" memory address.

So, if myArr has the value S1, then myArr + 1 has the value S2.

We know that *myArr is a name for the first item, because *x means the value at address x.

In that case, *(myArr + 1) is a name for the second item, because myArr + 1 gives the address S2.

So now we can label every item in the array with a name!

Indexing Syntax

If myArr is an array, then myArr[i] is exactly equivalent to *(myArr + i), and is a name for the item at index i.

So we can redraw our diagram as

Summary

Suppose that we declare an array a as int a[5];.

• Using the variable name a by itself gives us a memory address.
  • Specifically, a gives us the memory address of the first item in the array.
• To access the item at index i, you can use a[i].
• The compiler literally changes the syntax a[i] into this equivalent form: *(a + i).
  • a + i is the memory address at an offset of i from the address given by a.
  • So, in effect, a + i is the memory address of the item at index i, and
  • *(a + i) is the actual value at the address given by a + i.

Mysterious Mysteries Demystified (Optional)

(When logged in, completion status appears here.)