How array elements are retrieved?

Answer 1

Array elements are retrieved by specifying the offset of the element you want. Since array elements are a fixed size, you can also retrieve elements using simple pointer arithmetic. In actual fact, this is the underlying mechanism used when you supply an offset.

Consider the following array declaration:

int myArray[5] = { 1, 2, 3, 4, 5 };

Memory is allocated to myArray according to the type of the element specified. The type is int, therefore each element will be exactly 4 bytes in length. The subscript [5] allocates 5 elements to this array, thus 20 bytes (5 x 4 bytes) are allocated in total.

myArray refers to the first address of the memory location where the memory was allocated. It therefore refers to the first element in the array, which is offset 0. To retrieve the value stored at offset 0 we specify the offset as a subscript:

int x = myArray[0];

This effectively copies the value 1 (the value we stored in the first element) and places it in the memory allocated to x.

If we want to copy the last element, the fifth element, we specify the final offset, which is 4.

int y = myArray[4];

As before, this copies the value 5 and places it in the memory allocated to y.

Note that to access the nth element of an array, we specify the offset n-1. Offsets are zero-based, so the last element of an n dimension array is also offset n-1.

If we use pointers, we can better understand the underlying mechanism. myArray refers to the starting address of the entire array, so we can dereference the array by allocating a pointer to this memory location.

int * p = myArray;

This copies the address of myArray and stores it in the memory allocated to p. Therefore p points at the first element in the the array and we can retrieve the value of that element by using the indirection operator.

int z = *p;

This is the same as saying z = myArray[0].

To access the next element (found at offset 1), we simply increment the pointer's value by 1.

++p;

Note that if the value in p was originally the memory location 0x00123456, it is easy to assume it must now be 0x00123457 -- a difference of 1 byte. But p was declared as a pointer to int, so we actually increment the memory address by 4 bytes. So, p now stores the address of myArray[1].

So when we retrieve the element myArray[1], what we're really doing is accessing the value stored 1 x 4 bytes away (offset) from the memory location referred to by myArray. All this is done Behind the Scenes, but is no different to allocating a pointer to myArray, incrementing it by the specified offset, and finally returning the value through indirection.

We can also use indirection to change the value of an element:

*p = 10;

This is the same as saying:

myArray[1] = 10;

The only problem to be aware of when working with pointers is that your pointer can end up pointing at memory outside of the array. However the same can be said of any pointer. Always make sure you know what you're pointing at before attempting to access the value stored at that location.