Week 7 - Memory Management

Learning objectives

Upon finishing this week, you should be able to:

  • Accurately describe how a program is using the stack, heap and pointers
  • Use destructors and copy constructors appropriately in classes
  • Describe and diagram the difference between a deep and a shallow copy
  • Write simple container classes that manage dynamic memory

Suggested pacing

Day 1

  • Holiday

Day 2

Day 3

Day 4

Activity Outline

Dynamic Memory

Read Ch 22.1-22.6 on dynamic memory.

Do the HeapDrawing worksheet from the classroom files link. There is a HeapDrawingSample that shows step by step how to do the problems.

This optional video review the concepts:

Address Sanitizer

Read 22.7.

Watch this video on using Address Sanitizer:

Important Video

Do the Address Sanitizer screenshot assignment.

Windows Users - Setup WSL

If you are on Windows you should install Windows Subsystem for Linux (WSL). Address Sanitizer is not available on Windows, but it is available in WSL. So you need to use a codespace or WSL to use Address Sanitizer.

Longer term, you will increasingly find it useful to have a Linux environment available for programming. WSL is a great way to get that without needing to set up a separate machine or dual boot.

These instructions will help you get it set up and use it to build and run code:

WSL Installation and Use Guide

Arrays

Pointers and arrays are surprisingly interchangeable in C/C++.

Read 22.7-22.8.

Then do the Ch 22 Exercises.

This optional video reviews some of the concepts:

Container Classes

Read 22.10-22.15 on using classes to manage memory.

This optional video explains the core ideas:


And this one explains the copy constructor and assignment operator:

Tools for Managing Memory

Optional

Garbage Collection and Smart Pointers

You may be starting to realize that managing memory on our own is difficult and error-prone. Fortunately, it is not something that we always have to do. Many programming languages provide tools to help remove some of the burdens.

This video introduces two of these tools - garbage collection and smart pointers:

Rust

Rust is a programming language that uses ownership of memory as one of its core design principles. In Rust, the goal is to never have memory that is "shared". All memory is owned by exactly one reference. We may let the memory be borrowed temporarily by something like a function, but the original reference cannot use the memory while it is borrowed and the memory may only be borrowed by one reference at a time.

This video introduces this way of thinking about memory:

Rule of Five

Optional

In modern C++ there are two other operators related to the rule of three: the move constructor and move assignment operator. They are used to write efficient code, but are not necessary. Failing to use them does not cause the same kind of errors that forgetting to implement a destructor or custom assignment operator does. This level of efficiency is the kind of thing a professional C++ developer should care about - but for now we have better uses for your brain cells.

If you want to learn more about them check the learncpp.com coverage of move constructor and move assignment operator.