C++ Memory Management

I am not used to modern Cpp pointers. My background is more in using pointers the old fashioned way.

I highly recommend with modern versions of C++ that you look into using Smart Pointers over the new and delete keywords.

Learning the old way will help you understand what’s going on under the hood however.

Memory Management is the process of allocating and deallocating memory manually rather than letting the syntax handle the process for you. There are many use cases for it but here are some of the reasons to use it, and not to use it. These are similar to references in C#.

Many modern languages will manage this aspect of programming for you nowadays but every program at some level will have stack memory and heap memory. C++ and other low level languages just let you place variables and objects in whichever one you desire.

An example of where you might see the two used is, having the world data stored in the heap to be accessed by many different parts of the game engine including things like the render code in the stack.

The stack is a special area of memory which stores variables in the way you’ve probably been mostly using them, within scope of the functions and objects currently being run. Objects and variables used in your programs in stack memory are automatically deleted when the scope (Current function) has finished.

The Heap however is free form memory that can have objects and variables assigned to it manually using the new and delete keywords.

As simple as possible, pointers are just variables that store the location of other variables (aka references). Pointers are one of the hardest concepts for students to get their heads around sometimes, so I reccomend you look at other descriptions yourself such as here: w3schools. But it is an indispensable tool for optimisation and sharing heap memory objects between different objects and classes.

Consider the following program

Something that you might not know here is that every time you pass a variable to a function like this it duplicates it in the stacks memory, so if the variable changes in the function it doesn’t overwrite the original variable unless we tell it to with the = operator, which is another write to memory.

All that extra CPU/RAM time spent writing and deleting huge objects and variables from memory when we only want to change the original variable.

Introducing passing a variable to a function by reference.

In the above example you can see that we’re using the & symbol in the function description to pass a reference to the data that’s in the parent scope rather than the data itself to the function, passing the pointer to the object rather than the object’s data. Because of this we can manipulate the object in the function and not even return the data afterwards because the data of the original object we referenced was changed in the function.

A reference can also be stored in a variable denoted by it’s type and a * (e.g. A pointer that points to a variable of type int: int* variable;) to be passed to other objects.

This is especially useful for large chunks of data stored in the heap that needs to be manipulated by many pieces of code such as world data in a game.

And has a lifecycle that may last far longer than the code currently running function. Like a block change in minecraft on a chunk.

This is how you manually allocate memory to the heap manually. You use the new keyword to create an object and the delete keyword to remove it from the stack. Every single variable created with the new keyword must be deleted when your done with it if you don’t want that memory to hang around potentially build up and cause a memory leak.

You’d use this when you want to personally manage the lifecycle of an object and/or you want an object to last longer than the scope you defined it in.

If you allocate a array of certain object types to the heap this is also a great way of making sure that you don’t use more memory on that object than you want to, as by default in C++ most objects don’t grow in size, once you block out that memory in the heap you know exactly how much ram you’ve added to the program for the lifecycle of that array.

This is all well and good but on larger programs this stuff can become hard to manage. This is where RAII comes in. And is generally in C++ how you safely manage memory.

Using this sheet create a tic tac toe board with turns in C++ that only stores the board in the heap once and never in the stack (No need to check win conditions, just prove to yourself that you can manipulate the board through a pointer). Imagine you’re trying to run this game in as little an amount of ram as possible.