Edited By: Prof. Garth Santor

int main() {
    int i = 6;
    int* ptr = nullptr;
    ptr = &i;
    *ptr = 10;
}

In the previous code, we are keeping track of the reference (memory location) of i in the variable ptr. The type of that variable is an int pointer, signified with the ‘*’ after the type. The value of ptr is the memory address of i, assigned by getting at the reference of i. In order to get to the variable instead of the pointer value, we need to de-reference the pointer. This all sounds really confusing, so let’s look at it in action.

In the above screenshot, we can see that i resides at location 0x00D8FDE0. ptr holds the value of 0x00D8FDE0, which is the location of i. Notice that ptr has its own memory location, and can be moved and passed in to functions. In memory, ptr acts exactly like any other variable. The only difference to us is its value and method of access.

So when line 5 of the code executes: *ptr = 10 :

We can see that the value of i has changed to 10, even though we assigned it through ptr. So by dereferencing ptr, we were able to get at the variable at the memory location that is held by ptr, and manipulate that. Pretty cool right!

int main() {
    int* ptr = (int*) malloc(sizeof(int));

    if (ptr != nullptr) {
        *ptr = 10;
    }

    free(ptr);
}

So here we see that ptr has been created on the stack at 0x006FFA64. The value of that pointer is yet another reference, that addresses a location on the heap: 0x009B54E8. Notice how far these two locations are as opposed to the previous examples. That’s because the stack and the heap have a gap between them to account for their growth.

The last important part of this code is the free() function call. Since the stack is managed memory, the program will take care of cleaning it up for us and deleting any unused space. However, the heap is all up to us to clean up. That’s why we need to call free() on our pointer, telling it that we’re done with that memory now and can be used by other programs. Failure to do so will keep this memory locked down until the PC restarts. This failure is also called a memory leak.

Let’s watch what happens when free() is called:

class Foo {
public:
    int i;
};

An instance of Foo will take up however much space its components do, which in this case happens to be a single int value. So Foo will take up 4 bytes of memory.

So we see in the watch window that indeed, the instance of obj takes up exactly 4 bytes of memory, as much as its components, in which case the integer. obj is also located on the stack, at 0x0073F758. So what exactly does the new keyword do?

ptr was created on the stack, with a certain memory address stored in it. This memory address points to somewhere on the heap, and was provided to us by the new keyword. In fact, the new keyword is the C++ facade for malloc.

So if we inspect the memory address that ptr is holding, we will note that it’s in a completely different memory region than the stack:

Stepping over line 15, we see that our memory address holds the new value assigned to Foo’s i.

This shows us that C’s malloc() and C++’s new keyword give us the same results.

int main() {
    int* arr = (int*)malloc(5 * sizeof(int));

    if (arr != nullptr) {
        for (int i = 0; i < 5; ++i) {
            arr[i] = (i + 1) * 3;
        }

        int* iterator = arr;
        ++iterator;
        ++(*iterator);
    }

    free(arr);
}

The first line allocates 5 integer-size slots of memory on the heap, which gives us a pointer to the beginning of that memory collection. We've basically allocated our own array, and can now access it through the [] operator. So our array now contains multiples of 3, from 1 to 5. Note that calling arr[4], arr + 4. or arr - 3 (no assignment) does not change the value of arr. The program temporarily seeks forward or backward without manipulating arr. The proof to that is the following assignment of arr to iterator. Notice the watch window at the bottom and where arr and iterator are pointing to:

Both arr and iterator are pointing to the start of our array. So what happens if we run line 13: ++iterator which is equivalent to iterator += 1?

In the watch window we can see that iterator has advanced by one, and is now pointing to the next element in our array, without manipulating arr. That tells us that iterator is a copy of arr and does not affect the first pointer whatsoever. We can also see that nothing in our memory has changed, so no values were manipulated by advancing our iterator. So what does line 14 do?

By incrementing the dereferenced value of iterator, we see that indeed, our value has changed in memory. That has not affected iterator at all, only the memory that iterator now points to.
Lastly, notice what free does:

One common example is STL container iterators:

#include <vector>

int main() {
    std::vector<int> examScores {10, 14, 7, 9, 17, 0};
    long average = 0;
    for( std::vector<int>::iterator score = examScores.begin(); score != examScores.end(); ++score) {
        average += *score;
    }

    average /= examScores.size();
}

What we've basically done here is allocate a dynamic array on the heap using STL's vector object, and asked it for a managed pointer to its beginning (examScore.begin()). Then we were able to traverse our array by incrementing our iterator, and dereferencing it to retrieve the value it points to.
These structures are managed, meaning we don't need to worry about cleaning them up after we've exited our program, unless we're storing raw pointers in our vector.