Free, Unlimited Access

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++





<Excerpt>


An introduction to memory management within C++, starting with stack-allocated memory.


In the beginner course, we introduced the concept of the _**call stack**_, which is generated by the function calls in our program.


<LessonPromo slug=”debugging-functions” />


We can see the call stack in action using a class with a constructor and destructor:


```c++
#include <iostream>

class Character {
 public:
  Character(){
    std::cout << "Creating Character\n";
  }
  ~Character(){
    std::cout << "Destroying Character\n";
  }
};

void SelectCharacter() {
  // A new stack frame is created for
  // SelectCharacter.  Local variable Frodo is
  // allocated on the stack
  Character Frodo;
  // When SelectCharacter ends, Frodo is
  // deallocated. Destructor is called as the
  // stack frame is removed
}

int main() {
  std::cout << "Program Starting\n";

  // Call SelectCharacter, creating and
  // destroying Frodo
  SelectCharacter();
  // After SelectCharacter returns, its stack 
  // frame is removed. Memory used by Frodo is freed
  std::cout << "Program Ending\n";
}
```


```c++
//<o>
Program Starting
Creating Character
Destroying Character
Program Ending
```


If the concept of constructors and destructors are unfamiliar, I’d recommend reviewing this lesson:


</Excerpt>


<LessonPromo slug=”constructors” />


We’re already familiar that we can create objects within the local scope of our functions.  An example of this is the `Frodo` object, created within the `SelectCharacter()` function of our previous example.


## Stack Allocated Memory


Given we can create objects in our functions, we may have predicted, therefore, that the stack has memory available to store these objects.


This is indeed the case.  When we create variables in our functions, we are given the appropriate amount of memory from the stack to store those variables.


When the function ends, the stack frame is removed, local variables are deleted, and the memory is freed up for other uses.


However, while the stack is incredibly efficient for managing memory on a function-by-function basis, it is not without its limitations.


## Stack Limitation 1: Space


Typically, the size of the stack in a C++ program is determined by the operating system and the settings of the compiler used. For instance, on many systems, the default stack size might be around 1 MB to 2 MB.


This is generally sufficient for most routine operations and function calls. However, it's often not sufficient to store large objects, or large collections of objects.


Attempting to allocate large data structures on the stack can lead to a _**stack overflow**_, where the stack's limit is exceeded, potentially causing the program to crash or behave unpredictably.


<Ad />


## Stack Limitation 2: Flexibility


This form of memory management where objects are deleted automatically is often useful, but it does restrict our options


For example, consider a scenario where we want our `SelectCharacter` function to return a _**pointer**_ to the character:


```c++
#include <iostream>

class Character {
public:
  ~Character() {
    std::cout << "Destroying Character\n";
  }
  string Name { "Frodo" };
};

Character* SelectCharacter() {//<h>
  Character Frodo;
  return &Frodo;//<h>
}

int main() {
  Character* SelectedCharacter {
    SelectCharacter()
  };
  std::cout << "Getting Character Name:\n";
  std::cout << SelectedCharacter->Name;
}
```


The output of this program could be something like the following:


```c++
//<o>
Destroying Character
Getting Character Name:
1�I�^H�H�PTI�#@H�`#@H�@�* �D�f.�@�@
```


The fact that line 3 was garbage is perhaps predictable given the proceeding output.  The `Character` has already been destroyed by the time we come to log its name.  This is because it was allocated within the `SelectCharacter` function’s stack frame.


So, the `Frodo` pointer within our main function is pointing at memory no longer allocated to our program.


Hopefully, our compiler will have warned us of this:


```c++
//<oe>
warning: reference to stack memory associated
with local variable 'Frodo' returned
```


<Ad />


<Aside>


### Returning Stack-Allocated Data by Value


Updating the previous example to return `Frodo` by value rather than by reference would have worked as expected:


```c++
Character SelectCharacter() {//<h>
  Character Frodo;
  return Frodo;//<h>
}

int main() {
  Character SelectedCharacter {
    SelectCharacter()
  };
  std::cout << "Getting Character Name:\n";
  std::cout << SelectedCharacter.Name << '\n';
}
```


```c++
//<o>
Getting Character Name:
Frodo
Destroying Character
```


When we return something from a function, that data is moved to the stack frame that called our function.  In this example, it’s the `main` function that receiving `Frodo`  


When we return `Frodo` by value, we’re moving the `Frodo` object.  Now, the `Frodo` object is not destroyed when `SelectCharacter` ends.  It is instead moved to `main`, and only destroyed once `main` ends.


Previously, when we returned a pointer, we moved just the pointer to the `main` function.  The `Frodo` object is still within the `SelectCharacter` stack frame.  Therefore, it gets destroyed with the stack frame, and the pointer that was moved to `main` is no longer useful.


When an object has been deleted and a pointer that pointed to it has not been updated to reflect this, it is sometimes referred to as a _**dangling pointer**_.


</Aside>


<Ad />


## Preview: The Free Store


So far, we've delved into the workings of stack memory in C++ and its limitations. In the next lesson, we’ll explore the _**Free Store**_, often referred to as the _**Heap**_.


### What is the Free Store?


The Free Store is a region of memory that programs use to allocate objects whose lifetime is not tied to the scope of a function. Unlike stack memory, where objects are automatically managed and limited in size, the Free Store allows for _**dynamic memory allocation**_.


This means we can allocate memory at runtime, and it's your responsibility to free it when it's no longer needed.


### Why Learn About the Free Store?


Understanding the Free Store is crucial because:

1. **Flexibility in Memory Allocation**: It provides a more flexible way to manage memory, especially when dealing with large data or when the size of data is not known at compile time.
2. **Control Over Object Lifetimes**: Objects in the Free Store remain alive until they are explicitly destroyed, giving us more control over their lifetimes.
3. **Essential for Advanced C++ Features**: It lays the foundation for understanding more advanced C++ concepts like smart pointers and dynamic data structures.

### What We’ll Learn


In our upcoming lesson, we'll dive into:

- How to allocate and deallocate memory on the Free Store
- Best practices for managing dynamic memory
- Common pitfalls and how to avoid them
- Real-world examples to solidify our understanding

<FAQ>


```javascript
//<m>
{
  slug: 'stack-vs-heap',
  title: 'Stack vs Heap Memory',
  question: 'What are the key differences between stack and heap memory in C++?',
}
```


The stack and heap are two different areas of memory used in C++ programs:


**Stack Memory**:

- Managed automatically by the compiler
- Used for local variables and function parameters
- Memory is allocated and deallocated in a last-in-first-out (LIFO) order
- Fast allocation and deallocation
- Limited in size (typically 1-2 MB)
- Memory is freed when the function returns

**Heap Memory (Free Store)**:

- Managed manually by the programmer using `new` and `delete`
- Used for dynamic memory allocation
- Memory remains allocated until explicitly freed
- Slower allocation and deallocation compared to stack
- Much larger in size compared to stack
- Requires careful memory management to avoid leaks and dangling pointers

Example of stack allocation:


```c++
void function() {
  int x = 5;// Allocated on the stack
}// x is automatically deallocated
```


Example of heap allocation:


```c++
int* ptr = new int;  // Allocated on the heap
delete ptr;          // Explicitly deallocated
```


Proper understanding of stack and heap memory is crucial for effective memory management in C++.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'stack-overflow',
  title: 'Stack Overflow',
  question: 'What causes a stack overflow error, and how can it be prevented?',
}
```


A stack overflow error occurs when a program attempts to use more memory space than is available on the call stack. This typically happens due to:

- Excessive recursion without a proper base case
- Very large local arrays or structs
- Deep or infinite function call chains

Example of a function that may cause stack overflow:


```c++
void infinite_recursion() {
  // Recursive call with no base case
  infinite_recursion();//<e>
}
```


To prevent stack overflow:

1. Ensure recursive functions have a well-defined base case that stops recursion.
2. Avoid allocating large arrays or structs on the stack. Consider using dynamic allocation on the heap instead.
3. Optimize function call chains to reduce stack usage.
4. Increase stack size if necessary (not always possible).

Example of proper recursion with a base case:


```c++
void countdown(int n) {
  if (n == 0) {// Base case
    std::cout << "Countdown finished!\n";
    return;
  }
  std::cout << n << '\n';
  countdown(n - 1); // Recursive call
}
```


By understanding the limitations of the stack and employing good programming practices, you can avoid stack overflow errors in your C++ programs.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'dangling-pointers',
  title: 'Dangling Pointers',
  question: 'What is a dangling pointer, and how can it be avoided?',
}
```


A dangling pointer is a pointer that points to memory that has been deallocated or is no longer valid. This can happen in several situations:

- Returning a pointer to a local variable from a function
- Using a pointer after freeing the memory it points to
- Assigning a pointer to a memory location that has been reallocated

Example of a dangling pointer:


```c++
int* get_value() {
  int x = 5;

  // Returns a pointer to a local variable
  return &x;  //<e>
}

int main() {
  int* ptr = get_value();

  // Undefined behavior
  std::cout << *ptr << '\n';
}
```


To avoid dangling pointers:

1. Don't return pointers to local variables from functions.
2. Make sure not to use pointers after the memory they point to has been freed.
3. Be cautious when reassigning pointers to ensure they don't point to invalid memory.
4. Use smart pointers (e.g., `unique_ptr`, `shared_ptr`) to manage dynamic memory safely.

Example of avoiding a dangling pointer with a smart pointer:


```c++
#include <memory>
#include <iostream>

std::unique_ptr<int> get_value() {
  auto ptr = std::make_unique<int>(5);
  return ptr;  // Safely returns the unique_ptr
}

int main() {
  auto ptr = get_value();
  std::cout << "Value: " << *ptr; // Safe to use
}
```


```c++
//<o>
Value: 5
```


By understanding the concept of dangling pointers and following best practices, you can write more robust and error-free C++ code.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'dynamic-memory-allocation',
  title: 'Dynamic Memory Allocation',
  question: 'How do you dynamically allocate memory in C++, and why is it useful?',
}
```


In C++, dynamic memory allocation is the process of allocating memory at runtime using the `new` operator. The `new` operator returns a pointer to the allocated memory.


Example of dynamic memory allocation:


```c++
// Allocate an integer
int* ptr = new int;

// Allocate an array of 5 integers
int* arr = new int[5];
```


Dynamic memory allocation is useful in several scenarios:

1. When the size of the data is not known at compile time (e.g., user input).
2. When you need to allocate large amounts of memory that would exceed the stack size.
3. When you need data to persist beyond the scope of a function.

After dynamically allocating memory, it's important to deallocate it using the `delete` operator to avoid memory leaks.


Example of deallocating dynamically allocated memory:


```c++
// Deallocate the single integer
delete ptr;

// Deallocate the array of integers
delete[] arr;
```


It's also recommended to use smart pointers (e.g., `unique_ptr`, `shared_ptr`) that automatically handle memory deallocation.


Example of using a smart pointer for dynamic memory:


```c++
#include <memory>

// Allocate an integer
auto ptr = std::make_unique<int>(5);

// Allocate an array of 5 integers
auto arr = std::make_unique<int[]>(5);
```


By understanding dynamic memory allocation, you can create more flexible and efficient C++ programs that can handle varying amounts of data.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'stack-frame',
  title: 'Stack Frame',
  question: 'What is a stack frame, and how is it related to function calls in C++?',
}
```


A stack frame, also known as an activation record, is a memory block on the call stack that is created when a function is called. It stores information related to the function call, such as:

- Local variables
- Function parameters
- Return address (where to return after the function finishes)
- Saved registers

When a function is called, a new stack frame is pushed onto the call stack. When the function returns, its stack frame is popped off the stack, and the program continues from the return address.


Example of stack frames during function calls:


```c++
void function1() {
  int x = 5;
  function2();
}

void function2() {
  int y = 10;
  // ...
}

int main() {
  function1();
  // ...
}
```


Stack frames during execution:

1. `main()` is called, creating a stack frame for `main`.
2. `main()` calls `function1()`, creating a new stack frame for `function1`.
3. `function1()` calls `function2()`, creating a new stack frame for `function2`.
4. When `function2()` returns, its stack frame is popped off the stack.
5. When `function1()` returns, its stack frame is popped off the stack.
6. When `main()` ends, its stack frame is popped off the stack.

Understanding stack frames is essential for grasping function calls, recursion, and the scope of local variables in C++.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'memory-leaks',
  title: 'Memory Leaks',
  question: 'What is a memory leak, and how can it be prevented in C++?',
}
```


A memory leak occurs when dynamically allocated memory is not properly deallocated, leading to a gradual loss of available memory. This can happen when:

- Forgetting to use `delete` on dynamically allocated memory
- Losing track of pointers to dynamically allocated memory
- Not freeing memory in all possible code paths (e.g., exceptions)

Example of a memory leak:


```c++
void function() {
  int* ptr = new int;
  // ...
  
  // Forgot to delete ptr, causing a memory leak
  return;
}
```


To prevent memory leaks in C++:

1. Always deallocate dynamically allocated memory using `delete` when it's no longer needed.
2. Use smart pointers (e.g., `unique_ptr`, `shared_ptr`) that automatically handle memory deallocation.
3. Be cautious when using raw pointers, and ensure proper deallocation in all code paths.
4. Use memory profiling tools to detect and diagnose memory leaks.

Example of preventing a memory leak with a smart pointer:


```c++
#include <memory>

void function() {
  auto ptr = std::make_unique<int>();
  // ...
  return; // ptr is automatically deallocated
}
```


By adopting good memory management practices and utilizing smart pointers, you can prevent memory leaks and ensure your C++ programs use memory efficiently.


</FAQ>



Learn about stack allocation, limitations, and transitioning to the Free Store

Stack vs Heap Memory

Stack Overflow

Dangling Pointers

Dynamic Memory Allocation

Stack Frame

Memory Leaks

Added additional content, AI assistant, table of contents and references

CS225 | Stack and Heap Memory

Stack vs Heap Memory Allocation

Introduction to Stack Memory

Explore stack memory in C++ with this comprehensive lesson. Learn about stack allocation, limitations, and transitioning to the Free Store

Stack Frame

What is a stack frame, and how is it related to function calls in C++?

Memory Management and the Stack

What are the key differences between stack and heap memory in C++?

What causes a stack overflow error, and how can it be prevented?

What is a dangling pointer, and how can it be avoided?

How do you dynamically allocate memory in C++, and why is it useful?

What is a memory leak, and how can it be prevented in C++?

Memory Management and the Stack

Professional C++

This course includes:

Professional C++