Getting our machines set up for C++ development, and introducing the fundamental building blocks of programming - variables.

Getting our computer set up so we can create and build C++ programs. Then, creating our very first application

Setting up a C++ Development Environment

An introduction to the building blocks of our software - objects, and the variables that can be associated with them.

Objects, Variables and Types

Creating variables to store and update the data that describes our objects.  We also introduce comments, allowing us to describe our code in plain language.

Creating Variables

An introduction to the different types of numbers in C++, and how we can do basic math operations on them.

Numbers

An overview of the fundamental true or false data type, how we can create them, and how we can combine them.

Booleans - `true` and `false` values

Explore how C++ programs store and manage numbers in computer memory, including integer and floating-point types, memory allocation, and overflow handling.

Types and Literals

Creating a tiny program using numbers and booleans, then adding some breakpoints so we can step through our code in a debugger.

Introduction to Debugging

Types and Variables

Discover how we can package our code into reusable functions that we can easily call.  Then, learn how we can use conditionals and loops to control the flow of our program.

An introduction to functions - reusable blocks of code that we can use to break our application into smaller pieces.

Creating and Calling Functions

An introduction to how our function calls create a call stack, and how we can navigate it in a debugger.

The Call Stack and Debugging Functions

Use booleans and if statements to make our functions and programs more dynamic, choosing different execution paths.

Conditional Logic

Learn an alternative way to write conditionals, which is often used when we want to take different paths based on a specific value

Switch Statements

Allow our functions to communicate with their caller by returning values when they complete

Function `return` Statements

Going into more depth on what is happening when a variable is used as a different type

Implicit Conversions and Narrowing Casts

Making our functions more useful and dynamic by providing them with additional values to use in their execution

Function Arguments and Parameters

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

Scope

Understand what function prototypes are, and learn how we can use them to let us order our code any way we want.

Forward Declarations

Learn how we can use loops to iterate over a block of code, executing it as many times as needed.

Loops

Learn how we can use the modulus operator to get the remainder of integer division, and some common use cases.

The Modulus Operator (`%`)

Put everything we've learned in this chapter to the test by creating a C++ version of the Fizz Buzz game.

Fizz Buzz

Learn how the `&&` and `||` operators are optimized with short-circuit evaluation, only evaluating expressions when necessary

Short-circuit Evaluation

Functions, Conditionals and Loops

Classes and structs are the fundamental feature of object oriented programming.  In this chapter, we will see how we can set them up, and how we can use them to create the custom types our program needs.

Learn how to define, instantiate, and utilize classes, understanding how they form the backbone of object-oriented programming.

Abstraction and Classes

A guide to encapsulation, class invariants, and controlling data access with `public` and `private` specifiers.

Encapsulation and Access Specifiers

Learn about special functions we can add to our classes, control how our objects get created and destroyed.

Constructors and Destructors

Discover the role of structs, how they differ from classes, and how to initialize them without requiring a constructor.

Structs and Aggregate Initialization

This lesson introduces operator overloading, a fundamental concept to create more intuitive and readable code by customizing operators for user-defined types

Operator Overloading

This lesson introduces Structured Binding, a handy tool for unpacking simple data structures

Structured Binding

Classes and Structs

See how we can use inheritance to organise our classes into a hierarchy, unlocking a massive range of possibilities for building more complex software

In this lesson, we explore C++ inheritance, guiding you through creating and managing class hierarchies to streamline your code

Inheritance

Learn about `protected` class members in C++, including how and when to use them in your code, especially in the context of inheritance and class design

Protected Class Members

This lesson introduces Member Initializer Lists, focusing on their advantages for performance and readability, and how to use them effectively

Member Initializer Lists

This lesson provides an in-depth exploration of using inherited methods and variables in C++, covering constructor calls, variable modification, and function shadowing

Working with Inherited Members

An introduction to working with memory, and how we represent memory locations using references and pointers

This lesson introduces references, explaining how they work, their benefits, and their role in performance and data manipulation

References

This lesson provides a thorough introduction to pointers in C++, covering their definition, usage, and the distinction between pointers and references

Pointers

Learn about the `this` pointer in C++ programming, focusing on its application in identifying callers, chaining functions, and overloading operators.

The `this` Pointer

Learn about an important consideration when returning pointers and references from functions

Dangling Pointers and References

Memory, References and Pointers

An introduction to polymorphism - the key tool that let us build more complex programs whilst keeping our code simple.

This lesson provides an in-depth look at function overloading in C++, covering its importance, implementation, and best practices

Function Overloading

Explore the concept of static casting in C++, including examples and best practices for converting data types at compile time

Static Casting

This lesson provides an introduction to virtual functions and overrides, focusing on their role in enabling runtime polymorphism

Virtual Functions and Overrides

Get to grips with downcasting in C++, including static and dynamic casts. This lesson provides clear explanations and practical examples for beginners

Downcasting

Polymorphism

Go deeper on what is happening when we build our software.  Learn how we can use the preprocessor to automatically modify our source code before it is compiled, and how the linker connects our program together.

Explore the essential concepts of C++ preprocessing, from understanding directives to implementing macros

Preprocessor Definitions

Discover how the `#include` directive helps us include library features and split our project across multiple files.

The `#include` Directive

Explore how header files and linkers streamline C++ programming, learning to organize and link our code effectively

Header Files

The Preprocessor and the Linker

Discover additional methods and techniques to keep our data and code organised.

Learn the essentials of using namespaces to organize your code and handle large projects with ease

Namespaces

Learn about Enums and how they offer an efficient way to handle predefined values in your code

Enums

This lesson introduces the `using` keyword in C++, focusing on namespaces, enums, and type aliasing

The `using` Keyword

Namespaces and Enums

Learn how to store collections of objects, and take control of how memory is managed

Explore the fundamentals of dynamic arrays with an introduction to `std::vector`

Dynamic Arrays using `std::vector`

Learn how to manage dynamic memory using unique pointers and the concept of memory ownership

Memory Ownership and Smart Pointers

Explore advanced techniques for managing object copying and resource allocation

Copy Constructors and Operators

Learn the techniques and pitfalls of manual memory management in C++

Managing Memory Manually

Arrays and Dynamic Memory

Techniques to simplify our code, making it easier to understand and maintain

This lesson covers how we can ask the compiler to infer what types we are using through the `auto` keyword

Automatic Type Deduction using `auto`

Learn the intricacies of using `const` and how to apply it in different contexts

Constants and `const`-Correctness

This lesson provides an overview of effective commenting strategies, including Javadoc style commenting for automated documentation

Effective Comments and Javadoc

This lesson introduces the concept of Style Guides and ClangFormat, focusing on how to achieve consistency in our code

Style Guides and Automatic Code Formatting

An introduction to static analysis tools, and how they can help beginners learn faster and improve code quality

Static Analysis

Explore the fundamentals of attributes, including `[[nodiscard]]`, `[[likely]]`, and `[[deprecated]]`

Attributes

Clean Code

A collection of lessons covering a variety of topics worth learning as a beginner

This lesson covers the basics of using randomness, with practical applications

Random Number Generation

Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points

Dates, Times and Durations

A detailed guide to string formatting using C++20's `std::format()`, and C++23's `std::print()`

String Interpolation

Learn how to overload the `<<` operator, so our custom types can stream information directly to the console using `std::cout`

Overloading the `<<` Operator

This lesson introduces system calls, and how to use them to clear the terminal

System Calls and Terminal Management

This lesson introduces the fundamentals of capturing user input, using `std::cin` and `std::getline()`

User Input in the Terminal

Unravel the fundamentals of bitwise operators and bit flags in this practical lesson

Bitwise Operators and Bit Flags

Odds and Ends

This course is designed for beginners. We'll take you from the fundamentals and lay a solid foundation for creating real-world programs and learning more advanced concepts.

Become a software engineer with C++.  Starting from the basics, we guide you step by step along the way

This course teaches the fundamentals of C++ while instilling habits used by real-world developers. You'll gain practical experience with concepts that are the foundation of all modern programming.

No previous programming experience is needed - we start from the basics.

Start your Journey

We explain every line of code we're using, so you understand exactly what is happening.

Understand Every Line of Code

Everything we create is organised and implemented using modern, professional practices.

Use Professional Best Practices

We don't just explain what we're doing, but also why. This builds transferrable skills, so you can take what you've learnt and apply them to your own projects.

Focus on Transferrable Skills

No paywalls, no ads - the course is completely free with unlimited access

Free and Unrestricted Access

We break complex concepts into manageable steps, making even advanced topics feel approachable.

Step-by-Step Learning

What You'll Learn

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

Professional C++

If you're already familiar with the basics of C++ and object oriented programming, you may want to skip to the advanced course.  It starts with a quick summary of everything we cover here.

Already Familiar with Programming?

Intro to C++ Programming

In modern C++ programming, it's generally recommended to avoid raw pointers for several reasons related to safety, clarity, and maintainability.


## Safety


Raw pointers do not manage memory automatically. This puts the onus on us as developers to ensure the lifecycles of our objects are managed correctly.  If we don't accomplish thise, our program can have several problems.


### Memory Leaks


If you forget to call `delete` on a dynamically allocated object, you'll leak memory. For example:


```c++
void LeakyFunction() {
  int* p = new int(42); //<w>
  // Missing delete
}
```


Here, the allocated memory is not freed, leading to a memory leak.


### Dangling Pointers


After `delete` is called, the pointer still holds the address of the freed memory, which can lead to undefined behavior if accessed.


```c++
void DanglingFunction() {
  int* p = new int(42);
  delete p;
  *p = 10; //<w>
}
```


## Clarity and Maintenance


Raw pointers can make code harder to understand and maintain:

- **Manual Management**: You must manually manage the allocation and deallocation, increasing the likelihood of bugs.
- **Ownership Semantics**: It's not always clear who owns the memory or who is responsible for deleting it, making it difficult to manage lifetimes and ownership.

## Smart Pointers


Modern C++ provides smart pointers like `std::unique_ptr` and `std::shared_ptr` that handle memory management automatically.


### `std::unique_ptr`


This manages a resource with exclusive ownership, ensuring the resource is deleted when the `unique_ptr` goes out of scope.


```c++
void SafeFunction() {
  std::unique_ptr<int> p{
    std::make_unique<int>(42)};
}
```


Here, the memory is automatically freed when `p` goes out of scope.


### `std::shared_ptr`


This manages a resource with shared ownership, deleting the resource only when the last `shared_ptr` to it is destroyed.


```c++
void SharedFunction() {
  std::shared_ptr<int> p1{
    std::make_shared<int>(42)};

  // Both share ownership
  std::shared_ptr<int> p2{p1};
}
```


Using smart pointers helps avoid common pitfalls with raw pointers and makes your code safer and easier to manage.

Avoiding Raw Pointers

The `get()` method of smart pointers like `std::unique_ptr` and `std::shared_ptr` returns a raw pointer to the managed object. While this can be useful, it can also lead to some pitfalls.


## Pitfall 1: Avoiding Manual Memory Management


When you use `get()` to retrieve a raw pointer from a smart pointer, you might inadvertently start managing the memory manually. This can defeat the purpose of using a smart pointer. For example:


```c++
void DangerousFunction() {
  std::unique_ptr<int> p{
    std::make_unique<int>(42)};
  int* rawPtr = p.get();
  
  // Manual deletion - Bad practice
  delete rawPtr; //<e>
}
```


In this code, manually deleting `rawPtr` is incorrect because `p` still owns the memory, and deleting it results in undefined behavior.


## Pitfall 2: Avoiding Use After Free


If you store the raw pointer obtained from `get()` and use it later, it can lead to use-after-free errors. For example:


```c++
void UseAfterFree() {
  std::shared_ptr<int> p{
    std::make_shared<int>(42)};
  int* rawPtr = p.get();
  // p goes out of scope and the memory is freed
  std::cout << *rawPtr; //<e>
}
```


Accessing `rawPtr` after `p` is destroyed will result in undefined behavior because the memory has been deallocated.


## Best Practices

- **Prefer Smart Pointer Methods**: Instead of using `get()`, use the smart pointer methods directly when possible. For example, use `p` or `p->` instead of `p.get()` to access the value.
- **Avoid Manual Deletion**: Do not manually manage memory when using smart pointers; let them handle it for you.
- **Check for Null**: If you must use `get()`, always check if the returned raw pointer is not null before dereferencing it.

```c++
void SafeFunction() {
  std::unique_ptr<int> p{
    std::make_unique<int>(42)};
  int* rawPtr = p.get();
  if (rawPtr) {
    std::cout << *rawPtr; //<h>
  }
}
```


In this way, you can avoid the common pitfalls and leverage smart pointers effectively.

Smart Pointer Pitfalls

`std::unique_ptr` is designed for exclusive ownership of a resource, which complicates its use in classes that need to support copying and assignment, as `std::unique_ptr` itself is not copyable.


## Solution: Disable Copying


To manage resources with `std::unique_ptr` in a class that needs to support copying and assignment, you should disable copying and provide custom implementations for copy construction and assignment.


## Example


Consider a class `ResourceHandler` that manages a dynamic array with `std::unique_ptr`:


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

class ResourceHandler {
public:
  ResourceHandler(size_t size)
    : data(std::make_unique<int[]>(size)),
      size(size) {}

  // Disable copy construction and assignment
  ResourceHandler(const ResourceHandler&)//<h>
    = delete; //<h>
  ResourceHandler& operator=(
    const ResourceHandler&) = delete; //<h>

  // Provide move constructor and assignment
  ResourceHandler(
    ResourceHandler&& other) noexcept
    : data(std::move(other.data)),
      size(other.size) {
    other.size = 0; //<h>
  }

  ResourceHandler& operator=(
    ResourceHandler&& other) noexcept {
    if (this != &other) {
      data = std::move(other.data);
      size = other.size;
      other.size = 0; //<h>
    }
    return *this;
  }

  void Print() const {
    for (size_t i = 0; i < size; ++i) {
      std::cout << data[i] << ' ';
    }
    std::cout << '\n';
  }

private:
  std::unique_ptr<int[]> data;
  size_t size;
};
```


### Explanation

- **Copy Construction and Assignment Disabled**: By deleting the copy constructor and assignment operator, you prevent copying of `ResourceHandler` instances.
- **Move Semantics**: The move constructor and move assignment operator transfer ownership of the resource. The moved-from object is left in a valid but unspecified state (e.g., `size` is set to 0).

This approach ensures that each `ResourceHandler` instance has exclusive ownership of its resource and avoids problems related to copying.

Managing Resources with `std::unique_ptr`

When managing resources with smart pointers, you might wonder whether to use the `reset()` method or directly assign a new smart pointer. Each approach has its use cases and implications.


## Using `reset()`


The `reset()` method releases the current resource and optionally replaces it with a new one. It is useful when you want to explicitly manage the resource lifetime.


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

void ResetExample() {
  std::unique_ptr<int> p{
    std::make_unique<int>(10)};
  std::cout << *p << '\n';

  p.reset(new int(20)); //<h>
  std::cout << *p << '\n';
}
```


### Explanation

- **Explicit Resource Management**: Using `reset()` helps to clearly indicate when the resource is being released and replaced. This can be useful for debugging and ensuring resource cleanup.
- **Single Ownership**: `reset()` is particularly helpful when you want to change the managed object while maintaining the same smart pointer instance.

## Direct Assignment


Direct assignment creates a new smart pointer, effectively transferring ownership and potentially releasing the old resource.


```c++
void AssignmentExample() {
  std::unique_ptr<int> p1{
    std::make_unique<int>(10)};
  std::unique_ptr<int> p2{
    std::make_unique<int>(20)};

  p1 = std::move(p2); //<h>
  if (p2) {
    std::cout << *p2; //<w>
  }
  std::cout << *p1 << '\n';
}
```


### Explanation

- **Ownership Transfer**: Direct assignment with `std::move()` transfers ownership from `p2` to `p1`. The original `p2` becomes null.
- **Simpler Cases**: Direct assignment is straightforward and can be more readable in simpler cases where you are replacing the entire pointer.

## Summary

- **Use** **`reset()`** when you want to explicitly release and replace a resource while keeping the same smart pointer instance.
- **Use Direct Assignment** when you want to transfer ownership to a new smart pointer or when dealing with multiple smart pointers.

Both approaches are valid and can be chosen based on the specific needs of your code.

Using `reset()` vs Assignment

`std::unique_ptr` can be customized with a deleter to control how the managed resource is freed. This feature is useful for handling non-standard resource management scenarios.


## What is a Custom Deleter?


A custom deleter is a function or function object that defines how a resource should be released when the `std::unique_ptr` is destroyed. This is particularly useful when dealing with resources that require specific cleanup actions.


## Example


Here's how you can use a custom deleter with `std::unique_ptr`:


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

// Custom deleter function
void CustomDeleter(int* p) {
  std::cout << "Custom delete called\n";
  delete p;
}

void CustomDeleterExample() {
  std::unique_ptr<int, decltype(&CustomDeleter)>
    p(new int(10), CustomDeleter);
}
```


### Explanation

- **Custom Deleter Function**: `CustomDeleter` is defined to handle the deletion of `int` pointers. It prints a message and then deletes the pointer.
- **Usage with** **`std::unique_ptr`**: The `std::unique_ptr` is constructed with the custom deleter and a raw pointer. When the `std::unique_ptr` goes out of scope, `CustomDeleter` is called to clean up the resource.

## When to Use Custom Deleters

- **Non-Standard Cleanup**: When the resource requires special cleanup procedures, such as closing a file handle or releasing a database connection.
- **Integration with C Libraries**: When working with C libraries that use their own memory management functions.

## Summary


Custom deleters in `std::unique_ptr` provide flexibility for managing resources that need special handling upon release. By defining a custom deleter, you can ensure that the resource is properly cleaned up according to your specific requirements.

Custom Deleters with `std::unique_ptr`

A custom deleter is a powerful feature of `std::unique_ptr` that allows you to define a specific way to release a resource. This is particularly useful for resources that require custom cleanup.


## Example of Custom Deleter


Let's create an example where we manage a resource that requires a custom cleanup process:


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

// Custom deleter function
void CustomDeleter(int* p) {
  std::cout << "Custom delete called\n";
  delete p;
}

void CustomDeleterExample() {
  std::unique_ptr<int, decltype(&CustomDeleter)>
    ptr(new int(42), CustomDeleter);
  std::cout << *ptr;  // Output: 42
}
```


### Explanation


**Custom Deleter Function**: `CustomDeleter` is a function that prints a message and then deletes the pointer. It takes a raw pointer as an argument.


```c++
void CustomDeleter(int* p) {
  std::cout << "Custom delete called\n";
  delete p;
}
```


**Using with** **`std::unique_ptr`**: The `std::unique_ptr` is constructed with the raw pointer and the custom deleter. When the `unique_ptr` goes out of scope, it calls `CustomDeleter` to release the resource.


```c++
std::unique_ptr<int, decltype(&CustomDeleter)>
  ptr(new int(42), CustomDeleter);
```


**Output**: When the `unique_ptr` is destroyed, it outputs "Custom delete called" before deallocating the memory.


## When to Use Custom Deleters


Custom deleters are useful in several scenarios:

- **Non-Standard Resource Management**: When dealing with resources that do not use `new`/`delete` for allocation and deallocation, such as file handles or network connections.
- **Integration with Legacy Code**: When interfacing with C libraries that require specific cleanup functions.
- **Additional Logging**: For debugging purposes, custom deleters can provide additional information when resources are released.

## Conclusion


Custom deleters in `std::unique_ptr` offer flexibility in managing resources by allowing you to define specific cleanup actions. This can be particularly valuable for non-standard resources or when integrating with existing codebases.

Custom Deleters in Smart Pointers

Memory leaks in large and complex applications can be challenging to detect. Here are some effective strategies for identifying and addressing memory leaks:


## Use Memory Leak Detection Tools


**Valgrind**: One of the most popular tools for detecting memory leaks in C++ applications. It tracks memory allocations and deallocations and reports leaks.


```shell
//<ti>
valgrind --leak-check=full ./your_application
```


**AddressSanitizer (ASan)**: A runtime memory error detector built into modern compilers. It helps detect memory leaks and other memory-related issues.


```shell
//<ti>
g++ -fsanitize=address -g your_source_code.cpp -o your_application
./your_application
```


## Implement Smart Pointers


Using smart pointers like `std::unique_ptr` and `std::shared_ptr` helps manage resource lifetimes automatically and reduces the risk of memory leaks.


`std::unique_ptr` ensures exclusive ownership and automatic deallocation when the pointer goes out of scope.


```c++
std::unique_ptr<int> ptr{
  std::make_unique<int>(42)};
```


`std::shared_ptr` manages shared ownership of resources, cleaning up when the last `shared_ptr` is destroyed.


```c++
std::shared_ptr<int> ptr{
  std::make_shared<int>(42)};
```


## Code Reviews and Static Analysis


**Code Reviews**: Regularly reviewing code can help catch potential memory management issues. Look for places where `new` is used without corresponding `delete`.


**Static Analysis Tools**: Tools like Clang Static Analyzer and Cppcheck can analyze code to find potential memory management issues before runtime.


```shell
//<ti>
cppcheck --enable=all your_source_code.cpp
```


## Employ RAII (Resource Acquisition Is Initialization)


Using RAII principles ensures that resources are tied to the lifespan of objects. This means that when objects are destroyed, their resources are automatically cleaned up.


```c++
class Resource {
public:
  Resource() { /* allocate resource */ }
  ~Resource() { /* release resource */ }
};
```


## Track Memory Allocations


Manually tracking allocations and deallocations can help, especially in critical sections of the application. This can be done by overriding new and delete operators.


```c++
void* operator new(size_t size) {
  void* p = malloc(size);
  std::cout << "Allocated "
    << size << " bytes\n";
  return p;
}

void operator delete(void* p) noexcept {
  std::cout << "Deallocated memory\n";
  free(p);
}
```


## Profiling Tools


Profiling tools like Visual Studio Profiler, Intel VTune, and others provide insights into memory usage and help identify leaks.


## Conclusion


Combining these strategies-using dedicated tools, implementing smart pointers, performing code reviews, adhering to RAII principles, and tracking allocations-can significantly reduce the chances of memory leaks in complex applications.

Detecting Memory Leaks in Complex Applications

The Rule of Three in C++ is a guideline that states if a class needs to define one of the following special member functions, it likely needs to define all three:

1. Destructor
2. Copy Constructor
3. Copy Assignment Operator

## How the Rule of Three Applies


The Rule of Three is traditionally concerned with managing resource ownership and cleanup. However, when using `std::unique_ptr`, the Rule of Three changes slightly:


## Destructor


With `std::unique_ptr`, you don't need to define a custom destructor unless you need to perform additional cleanup. `std::unique_ptr` automatically handles the deletion of the managed resource when the object is destroyed.


```c++
class MyClass {
 public:
  std::unique_ptr<int> ptr;
  MyClass() : ptr(std::make_unique<int>(42)) {}
  // Destructor is automatically generated
  // and manages resource cleanup
};
```


## Copy Constructor


`std::unique_ptr` is not copyable. It enforces unique ownership, so copying is not allowed. If you attempt to copy a `std::unique_ptr`, it will result in a compile-time error.


```c++
MyClass obj1;

// Error: std::unique_ptr cannot be copied
MyClass obj2 = obj1; //<e>
```


## Copy Assignment Operator


Similar to the copy constructor, the copy assignment operator is deleted for `std::unique_ptr`. You can only move `std::unique_ptr`, which transfers ownership.


```c++
MyClass obj1;
MyClass obj2;

// Correct: moves ownership from obj1 to obj2
obj2 = std::move(obj1); //<h>
```


## Move Semantics


Since `std::unique_ptr` does not allow copying, it relies on move semantics:


**Move Constructor**: Transfers ownership from one `std::unique_ptr` to another.


```c++
std::unique_ptr<int> ptr1{
  std::make_unique<int>(42)};
  
// Ownership transferred to ptr2
std::unique_ptr<int> ptr2{
  std::move(ptr1)};
```


**Move Assignment Operator**: Assigns ownership from one `std::unique_ptr` to another.


```c++
std::unique_ptr<int> ptr1{
  std::make_unique<int>(42)};
std::unique_ptr<int> ptr2;

// Ownership transferred to ptr2
ptr2 = std::move(ptr1);
```


## Conclusion


When using `std::unique_ptr`, the Rule of Three does not apply in the traditional sense since `std::unique_ptr` is non-copyable and manages its own resource cleanup.


Instead, focus on understanding and using move semantics with `std::unique_ptr` for efficient resource management.

Rule of Three and `std::unique_ptr`

Updated explanations to clarify that `GetArt()` and `HandleArt()` are poorly-designed functions

Improved some explanations and fixed typo in `Dungeon` class

Updated code example to use aggregate initialization

Abstract art representing computer programming

`new` expression

`delete` expression

Resource Acquisition Is Initialization (RAII)

Rule of Three/Five/Zero

`std::unique_ptr`

`std::make_unique()`

Valgrind Tool for Memory Debugging

{CPP}Explore advanced memory management in C++, focusing on RAII, smart pointers, and avoiding common pitfalls like memory leaks and double-free errors.

Managing Memory Manually

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers