6.8a — Pointer arithmetic and array indexing

Pointer arithmetic

The C++ language allows you to perform integer addition or subtraction operations on pointers. If ptr points to an integer, ptr + 1 is the address of the next integer in memory after ptr. ptr - 1 is the address of the previous integer before ptr.

Note that ptr + 1 does not return the memory address after ptr, but the memory address of the next object of the type that ptr points to. If ptr points to an integer (assuming 4 bytes), ptr + 3 means 3 integers (12 bytes) after ptr. If ptr points to a char, which is always 1 byte, ptr + 3 means 3 chars (3 bytes) after ptr.

When calculating the result of a pointer arithmetic expression, the compiler always multiplies the integer operand by the size of the object being pointed to. This is called scaling.

Consider the following program:

On the author’s machine, this output:


As you can see, each of these addresses differs by 4 (7C + 4 = 80 in hexadecimal). This is because an integer is 4 bytes on the author’s machine.

The same program using short instead of int:

On the author’s machine, this output:


Because a short is 2 bytes, each address differs by 2.

Arrays are laid out sequentially in memory

By using the address-of operator (&), we can determine that arrays are laid out sequentially in memory. That is, elements 0, 1, 2, … are all adjacent to each other, in order.

On the author’s machine, this printed:

Element 0 is at address: 0041FE9C
Element 1 is at address: 0041FEA0
Element 2 is at address: 0041FEA4
Element 3 is at address: 0041FEA8

Note that each of these memory addresses is 4 bytes apart, which is the size of an integer on the author’s machine.

Pointer arithmetic, arrays, and the magic behind indexing

In the section above, you learned that arrays are laid out in memory sequentially.

In lesson 6.8 -- Pointers and arrays, you learned that a fixed array can decay into a pointer that points to the first element (element 0) of the array.

Also in a section above, you learned that adding 1 to a pointer returns the memory address of the next object of that type in memory.

Therefore, we might conclude that adding 1 to an array should point to the second element (element 1) of the array. We can verify experimentally that this is true:

Note that when dereferencing the result of pointer arithmetic, parenthesis are necessary to ensure the operator precedence is correct, since operator * has higher precedence than operator +.

On the author’s machine, this printed:


It turns out that when the compiler sees the subscript operator ([]), it actually translates that into a pointer addition and dereference! Generalizing, array[n] is the same as *(array + n), where n is an integer. The subscript operator [] is there both to look nice and for ease of use (so you don’t have to remember the parenthesis).

Using a pointer to iterate through an array

We can use a pointer and pointer arithmetic to loop through an array. Although not commonly done this way (using subscripts is generally easier to read and less error prone), the following example goes to show it is possible:

How does it work? This program uses a pointer to step through each of the elements in an array. Remember that arrays decay to pointers to the first element of the array. So by assigning ptr to name, ptr will also point to the first element of the array. Each element is dereferenced by the switch expression, and if the element is a vowel, numVowels is incremented. Then the for loop uses the ++ operator to advance the pointer to the next character in the array. The for loop terminates when all characters have been examined.

The above program produces the result:

Mollie has 3 vowels
6.8b -- C-style string symbolic constants
6.8 -- Pointers and arrays

43 comments to 6.8a — Pointer arithmetic and array indexing

  • programmer, another one

    just wanna say great that these are great tutorials, and nice to see that you are back.

    also, will there be any tutorials on linked lists anytime soon?


    • Alex

      Probably not, since linked lists are more of an data structures topic than a C++ topic.

      I’d like to get there someday, but right now my focus is on the core language concepts.

  • Simon

    Alex, possible small issue here:

    The given result above:

    Looks to be inverted, given the code example above it.

  • 1. "Note that ptr + 1 does not return the memory address after ptr, but the next object of the type that ptr points to"

    shouldn’t it be:

    Note that ptr + 1 does not return the memory address after ptr, but the address of next object of the type that ptr points to"
    or something like that..

    2. "In lesson 6.8 -- Pointers and arrays, you learned that an array can decay into to a pointer that points to the first element (element 0) of the array."

    Note that "into to" part. Remove "to" from the above sentence.

  • kyle

    can you please explain what "ptr < name + arraySize" means? I get for loops, i just don’t understand how you added name and arraysize and what the sum would be. I copied your example into codeblocks and added "std::cout << name + arraySize;", to try to find out but all it does is cause a beeping noise (and no errors).

    • Alex

      Sure. We know that name points to the first element of the array, right? So name maps to index 0. We also know that using pointer arithmetic, name + 1 maps to index 1.

      Based on this, we can draw up a table correlating the index with the memory address, like this:

      Index		Address
      0		name
      1		name + 1
      2		name + 2
      ...		...
      arraySize	name + arraySize

      ptr is originally set to the address held in array name, which is the address of element 0. As we loop through the array, we increment ptr by 1 each time, which moves us to the next element. We stop when we get to name + arraySize, because that’s the memory address of the element just beyond the end of the array.

      Basically, instead of iterating through the array based on the left hand column (index), we’re iterating through the array based on the right hand column (memory address).

      Make sense?

      • Baubas

        If it is a memory address name + arraySize why we can’t get that address? Now cout shows something crazy, not the memory address.

        • Alex

          You can get the address. What are you seeing?

          • Baubas

            I tried this: cout<<name + arraySize; and got the garbage. But then I tried this: cout<<name + arraySize-1; and got the empty space and finally I understood what was going here.

            for (char *ptr = name; ptr < name + arraySize-1; ++ptr)
            I think it would be more easily to understand for beginners. The last symbol is the empty space so we can add -1, it doesn’t hurt but it is more clearly. You can separately  cout<< both ptr and name + arraySize-1 and compare the result.

            Until now I mix how to write the address and the value . Then I get that garbage I feel so stupid 😀

            • Alex

              No, that’s definitely not better, and that only works for strings (which have a null terminator), not other kinds of data (e.g. arrays).

              Remember that the conditional in the for loop is “ptr < name + arraySize” -- note the less than. That means this loop never executes the iteration where ptr == name + arraySize.

  • Mr D

    Hi Alex,

    I’ve been messing round with the code from this lesson and i can’t work out why:

    prints out:


    So when a pointer points to a certain element of an array, it actually points to that element plus everything else after it in the array?

    • Alex

      No, a pointer that points to a certain element of the array only points to that element.

      The issue you are seeing here is a result of the way std::cout work. std::cout treats objects of type char* as a C-style string. So if you pass it a char* pointer, it will print everything starting from that element until it hits a null terminator.

  • Awesome tutorials. This acts as an additional help for me after school. Thanks to the author.

  • Rob G.

    Bubble sort w/ pointers working example below

    Hi Alex I was inspired by the sections on pointers so I applied them to the bubble sort a few exercises back. It took a while but I think I understand pointers even better now. I had some difficulties at first with  "lvalue required as left operand of assignment" that were resolved by correctly applying value-to-value, e.g. (pp_ptr+1) = value_1 (error);
    correct: *(pp_ptr+1) = value_1.  ->*ptr is treated the same as value,ptr is the same as &value.Thanks for such a great site Alex.

  • Rob G.

    Optimized bubble sort below


    . Element num is decremented outside of the inner loop, reducing the outer limit value of the inner loop when it recycles. By correctly reducing the outer limit range, values already analyzed are not analyzed again. Thus the inner loop recycles without a redundancy in scanning the array.

  • Rob G.

    I forgot to put that as the adjustment to convert bubble sort to optimized bubble sort above. Sorry!

  • Rob G.

    Alex, when posting, is it more appropriate for your site to post an .hpp file with .cpp -- for function calls -- or post a single .cpp file that includes the functions? Some of the programs are starting to grow.

    Thx Rob G.

    • Alex

      .h files are really only needed if you have declarations you plan to share across multiple files. For trivial exercises and tutorials, it’s mostly not necessary.

  • Rob G.

    Thx Alex the exercises and tutorials don’t feel trivial at all. Please keep up the great job.

  • lance

    what is the purpose of the break in the switch in the final program. i ran it without it on mollie and Mmmmmm and they both worked.

  • Shiva


    Beneath the last example you wrote, ‘First, we start with a pointer assigned to array, which points to element 0.’ The wording feels a bit odd; surely it should be something like: ‘First, we start with the array assigned to a pointer /* ∵ char *ptr = name; */, which then points to element 0 of the array’, right? Also in your sentence the which-clause seems to refer to ‘array’ when it should refer to ‘a pointer’. Anyway, I’m not a native English speaker, so I could be wrong.

    Regarding the lesson, correct me if I’m wrong:
    > The subscript operator is an operator in C++ that takes a pointer (not an array) and an integer as operands.
    > Thus when it is used on an array variable to obtain one of its elements, the array variable actually decays in to a pointer before the operation is performed.
    > When it comes in an expression, an array variable first decays into a pointer, which then evaluates to the address it is holding, that is to say the base address of the array.

    To summarise, wherever an array identifier shows pointer behaviour, are the places where it loses it’s array-ness and decays into pointer-ness. And indexing is one of such places. Is my understanding correct?

    • Alex

      I’ve updated the wording of the sentence you pointed out. The name of the array variable used to be array, but I changed it and missed the fact that it was used in the sentence too. Thanks for pointing that out.

      All of your other sentences appear to be correct to the best of my understanding.

  • Indorfin

    I thought this was worth posting just to show how I’ve kept including the new material; thanks again for these tutorials!

  • Chris


    i have questions about pointer arithmetic on integer array. each element address separate by 3 memory address. the questions is:

    1. is it true if 1 memory address just capable for 1 byte data? so allocate int variable must have 4 memory address, if short variable must have 2 memory address?

    2. how about the 3 memory address? how to access them? what is in there?

    Thank you.

    • Alex

      Yes, most modern machines are byte-addressable, meaning each memory address can be used to access one byte. For variables that need more than one byte, they just use consecutive memory addresses (e.g. a 32-bit integer uses 4 consecutive memory addresses). Therefore, if you have an array of 32-bit integers, each one will be separated by 4 bytes.

      Pointer arithmetic accounts for this. ptr+1 will add one address if ptr is pointing to a 1-byte char, but it will add 4 if ptr is pointing to a 4-byte integer.

  • Nyap

    so doing pointer+1 doesn’t find the next valid integer in memory, it just moves the memory address in pointer by 4 and the next 4 bytes are interpreted as an integer (so if there’s supposed to be a double there it’s just interpreted as an integer)

    • Alex

      Yep, if pointer is an integer pointer, then pointer+1 will move the address by 4 bytes. If you then dereference that pointer, it will interpret the next 4 bytes starting at that address as an integer.

  • rtz

    given the base address  of a pointer chain is it possible to reach the address where the actual value is stored.what i have been trying to achieve is something like this.

    how do i implement this?

    • Alex

      I’m not sure I understand what the point of this exercise is. If you already know that base is of type int****, then just dereference base 3 times and you’ll have a pointer to your value. That pointer will be holding the address of your value.

  • Raquib

    Hi Alex,

    I have a simple query-

    I ran the above code and got the o/p as -

    Address of first element using address-of-operator(&): 0x7ffe b215 7f00
    Address of second element using address-of-operator(&): 0x7ffe b215 7f04
    Address of third element using address-of-operator(&): 0x7ffe b215 7f08

    Size f the pointer: 8

    Suggesting I am running on a 64-bit machine, which is true.

    But, when I am looking at the address- why is the address 48-bit??

    In your example you were running on a 32-bit machine, the size of the pointer was 4 byte (32-bit) and the address was something like -  0x 0012 FF7C (32-bit address).

    What am I missing??

    Raquib Buksh

    • Alex

      Are you on an AMD 64-bit machine? As I understand it, the machine has 64-bits available for addressing -- but to save on transistors, those CPUs only actually use the lower 48-bits for addressing (the top 16 bits are ignored). Thus, even though you have 64-bits available, you get addresses that only contain 3 bytes. 48-bits is enough to address 256 terabytes of memory, so you won’t be hitting that anytime soon.

  • Kılıçarslan

    Hey Alex,do you think is this a good alternative to iterate through an array using pointers?

  • Slayther

    "If ptr points to an integer (assuming 4 bytes), ptr + 3 means 3 integers after ptr, which is 12 memory addresses after ptr. If ptr points to a char, which is always 1 byte, ptr + 3 means 3 chars after ptr, which is 3 memory addresses after ptr."

    It should be 3 memory addresses and not 12. (Not that a memory address is a defined unit, but it’s fine for an explanation)
    Unless you meant bytes, which should be then corrected as well.

    • Slayther


      "ptr + 3 means 3 integers after ptr"

      It might be odd to talk about integers instead of memory addresses here. You might want to find a different way to phrase this, if you agree.

      • Alex

        I think it makes sense to talk about it that way -- because when you do pointer arithmetic, the pointer moves relative to the size of the object being pointed to. If ptr were pointing to a double, ptr+3 would move 3 doubles. Nevertheless, I’ve tweaked the wording slightly, moving away from “memory addresses” to “bytes”, even though they’re essentially synonymous for byte-addressable architectures.

Leave a Comment

Put C++ code inside [code][/code] tags to use the syntax highlighter