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

Returning pointers or references safely from a function requires careful consideration of object lifetimes. Here are some techniques to avoid dangling pointers:


## Return by Value


The simplest and often safest approach is to return objects by value instead of using pointers or references:


```c++
#include <string>

std::string GetName() {
  std::string name{"Alice"};
  return name;
}

int main() {
  std::string result = GetName();
}
```


This approach creates a copy (or move) of the object, ensuring the returned value remains valid.


## Static Local Variables


If you need to return a pointer or reference, you can use a static local variable:


```c++
#include <string>

const std::string& GetConstantName() {
  static const std::string name{"Bob"};
  return name;
}

int main() {
  const std::string& result = GetConstantName();
}
```


Static local variables have program lifetime, so the reference remains valid. However, be cautious as this creates shared state between function calls.


## Dynamic Allocation


You can return a pointer to a dynamically allocated object:


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

std::unique_ptr<std::string> GetDynamicName(){
  return std::make_unique<std::string>(
    "Charlie");
}

int main(){
  std::unique_ptr<std::string> result =
    GetDynamicName();
}
```


This approach uses smart pointers to manage the object's lifetime, preventing memory leaks.


Remember, the key to avoiding dangling pointers is ensuring the pointed-to object outlives the pointer or reference. Always consider object lifetimes when designing your functions and choose the appropriate technique based on your specific needs.

Safely Returning Pointers and References

Yes, there are several tools and compiler flags that can help detect potential dangling pointer issues. These can be invaluable for catching and preventing these tricky bugs. Let's explore some options:


## Compiler Warnings


Modern C++ compilers offer warnings for many potential issues, including some cases of dangling pointers:


```c++
#include <iostream>

int* GetLocalInt() {
  int local{42};
  return &local;  //<w>
}

int main() {
  int* result = GetLocalInt();
  std::cout << *result;
}
```


Compiling this with warnings enabled (e.g., `-Wall -Wextra` for GCC/Clang) will produce:


```plain text
//<oe>
warning: address of local variable 'local' returned [-Wreturn-local-addr]
```


## Static Analysis Tools


Static analyzers examine your code without running it. Some popular options include:

1. Clang Static Analyzer: Part of the LLVM project, it can detect many memory-related issues.
2. Cppcheck: An open-source static analysis tool for C/C++.
3. PVS-Studio: A commercial static analyzer with advanced detection capabilities.

## Dynamic Analysis Tools


These tools monitor your program as it runs:

1. [Valgrind](https://valgrind.org/): A powerful tool suite for debugging and profiling. Its Memcheck tool can detect many memory-related errors.
2. [AddressSanitizer](https://clang.llvm.org/docs/AddressSanitizer.html): A fast memory error detector, available in GCC and Clang.

Here's how you might compile a program with AddressSanitizer:


```plain text
//<ti>
g++ -fsanitize=address -g yourprogram.cpp -o yourprogram
```


## Smart Pointers and RAII


While not tools per se, using smart pointers and RAII (Resource Acquisition Is Initialization) can prevent many dangling pointer issues:


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

std::unique_ptr<int> GetUniqueInt() {
  return std::make_unique<int>(42);
}

int main() {
  auto result = GetUniqueInt();
  std::cout << *result;
}
```


```plain text
//<o>
42
```


This code uses `std::unique_ptr` to manage the dynamically allocated integer, preventing dangling pointers and memory leaks.


Remember, while these tools are helpful, they're not perfect. Good coding practices and thorough code reviews are still essential for writing safe and reliable C++ code.

Tools for Detecting Dangling Pointers

Explaining dangling pointers to junior developers can be tricky, but using analogies and clear examples can help. Here's an approach you might take:


## The Library Book Analogy


Start with a relatable analogy:


"Imagine you're in a library. You find a book you like and write down its shelf location on a piece of paper. This piece of paper is like a pointer - it tells you where to find the book.


Now, imagine someone removes that book from the shelf and returns it to the sorting cart. Your piece of paper still has the same shelf location written on it, but the book isn't there anymore.


If you try to use that location to find the book, you'll either find nothing or a different book entirely. This is similar to a dangling pointer."


## Code Example


Use a concrete code example:


```c++
#include <iostream>

int* CreateNumber() {
  int num{42};
  return &num; //<w>
}

int main() {
  int* ptr = CreateNumber();
  std::cout << "The number is: " << *ptr;
}
```


Explain that `CreateNumber()` returns the address of a local variable `num`. When the function ends, `num` is destroyed, but `ptr` still holds its address. Using `ptr` after this point is undefined behavior - like trying to find a book that's no longer on the shelf.


## Visualizing Memory


Use a diagram or ASCII art to visualize what's happening in memory:


```plain text
//<o>
Before CreateNumber() returns:
+-------------------+
| CreateNumber()    |
|  +---+            |
|  |num| 42         |
|  +---+            |
+-------------------+

After CreateNumber() returns:
+-------------------+
| main()            |
|  +---+            |
|  |ptr| ----+      |
|  +---+     |      |
|            |      |
|            v      |
|         ???????   |
+-------------------+
```


## Consequences


Discuss the potential consequences:

1. Crashes: The program might crash if it tries to access memory it no longer owns.
2. Corrupted data: The memory might now contain different data, leading to unexpected behavior.
3. Security vulnerabilities: In some cases, dangling pointers can be exploited by malicious actors.

## Prevention


Finally, discuss how to prevent dangling pointers:

1. Be mindful of object lifetimes.
2. Use smart pointers like `std::unique_ptr` and `std::shared_ptr`.
3. Avoid returning pointers or references to local variables.
4. Use static analysis tools and compiler warnings to catch potential issues.

Remember, understanding comes with practice. Encourage your junior developers to experiment with code examples and use debugging tools to see dangling pointers in action.

Explaining Dangling Pointers to Junior Developers

Different programming languages handle issues similar to dangling pointers in various ways. Let's explore how some popular languages approach this problem:


## Garbage-Collected Languages


Languages like Java, Python, and JavaScript use garbage collection to automatically manage memory:


```java
public class Example {
  public static String createString() {
    String local = "Hello, World!";
    return local;
  }

  public static void main(String[] args) {
    String result = createString();
    System.out.println(result);
  }
}
```


```plain text
//<o>
Hello, World!
```


In this Java example, you don't need to worry about dangling pointers. The garbage collector keeps track of object references and frees memory when it's no longer needed.


## Rust: Ownership and Borrowing


Rust prevents dangling pointers at compile-time through its ownership system:


```rust
fn create_string() -> String {
  let local = String::from("Hello, World!");
  local // Ownership is moved to the caller
}

fn main() {
  let result = create_string();
  println!("{}", result);
}
```


```plain text
//<o>
Hello, World!
```


Rust's borrow checker ensures that references don't outlive the data they refer to.


## Go: Escape Analysis


Go uses escape analysis to determine if it's safe to allocate objects on the stack:


```go
package main

import "fmt"

func createString() *string {
  local := "Hello, World!"
  
  // Go compiler will allocate this on the heap
  return &local
}

func main() {
  result := createString()
  fmt.Println(*result)
}
```


```plain text
//<o>
Hello, World!
```


If a local variable escapes its function, Go allocates it on the heap instead of the stack.


## Swift: Automatic Reference Counting (ARC)


Swift uses ARC to track and manage memory usage:


```swift
class MyClass {
  var value: String

  init(_ value: String) {
    self.value = value
  }
}

func createObject() -> MyClass {
  let local = MyClass("Hello, World!")
  return local // ARC increases the reference count
}

let result = createObject()
print(result.value)
```


```plain text
//<o>
Hello, World!
```


ARC automatically frees objects when their reference count drops to zero.


## C#: Managed Code


C# runs in a managed environment with garbage collection:


```c#
using System;

class Program
{
  static string CreateString()
  {
    string local = "Hello, World!";
    return local;
  }

  static void Main()
  {
    string result = CreateString();
    Console.WriteLine(result);
  }
}
```


```plain text
//<o>
Hello, World!
```


Like Java, C# handles memory management automatically in most cases.


While these languages have different approaches, they all aim to prevent issues like dangling pointers. C++ offers more direct control over memory, which can lead to higher performance but requires more careful management.


Understanding these differences can help you choose the right tool for your project and write safer code in any language.

Dangling Pointers in Other Programming Languages

Managing object lifetimes in complex C++ applications is crucial for writing safe and efficient code. Here are some best practices to help you navigate this challenge:


## Use RAII (Resource Acquisition Is Initialization)


RAII is a fundamental C++ technique where resource management is tied to object lifetime:


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

class FileHandler {
  std::unique_ptr<std::fstream> file;

public:
  FileHandler(const std::string& filename)
    : file{std::make_unique<std::fstream>(
      filename
    )} {}

  // File is automatically closed when FileHandler
  // is destroyed
};

void processFile(const std::string& filename) {
  FileHandler handler{filename};
  // Use handler...
} // File is closed when handler goes out of scope
```


## Prefer Stack Allocation


When possible, allocate objects on the stack:


```c++
void processLargeObject() {
  BigObject obj;  // Stack-allocated
  // Use obj...
}  // obj is automatically destroyed here
```


Stack allocation is usually faster and automatically manages object lifetime.


## Use Smart Pointers


When dynamic allocation is necessary, use smart pointers:


```c++
#include <memory>

void processData() {
  auto data = std::make_unique<LargeData>();
  // Use data...
}  // data is automatically deleted
```


`std::unique_ptr` for exclusive ownership, `std::shared_ptr` for shared ownership.


## Be Careful with Circular References


Circular references can lead to memory leaks with `std::shared_ptr`. Use `std::weak_ptr` to break cycles:


```c++
#include <memory>

class Node {
  std::shared_ptr<Node> next;

  // Prevents circular reference
  std::weak_ptr<Node> prev;

public:
  void setNext(std::shared_ptr<Node> n){
    next = std::move(n);
  }

  void setPrev(std::shared_ptr<Node> p){
    prev = p;
  }
};
```


## Use Move Semantics


Utilize move semantics to transfer ownership efficiently:


```c++
std::unique_ptr<BigObject> createObject() {
  return std::make_unique<BigObject>();
}

void useObject() {
  // Ownership is moved, not copied
  auto obj = createObject();
  // Use obj...
}
```


## Be Mindful of Object Relationships


Consider object relationships when designing your classes:


```c++
class Engine; // Forward declaration

class Car {
  // Car owns Engine
  std::unique_ptr<Engine> engine;

public:
  Car() : engine{std::make_unique<Engine>()}{}
};
```


Here, `Car` owns `Engine`, so when `Car` is destroyed, `Engine` is automatically destroyed too.


## Use Factory Functions


Factory functions can help manage complex object creation and lifetime:


```c++
#include <memory>

class ComplexObject {
  // Private constructor
  ComplexObject() = default;

public:
  static std::unique_ptr<ComplexObject>
  create(){
    auto obj =
      std::unique_ptr<ComplexObject>(
        new ComplexObject());

    // Complex initialization...
    return obj;
  }
};
```


This ensures objects are always properly initialized and managed.


Remember, these practices work best when combined with good overall design, thorough testing, and use of static analysis tools. Always consider the specific needs of your application when applying these techniques.

Best Practices for Managing Object Lifetimes

The RAII (Resource Acquisition Is Initialization) principle is a powerful C++ technique that can help prevent dangling pointers. Let's explore how these concepts are related:


## Understanding RAII


RAII ties resource management to object lifetime. The basic idea is:

1. Acquire resources in the constructor
2. Use the resources in object methods
3. Release resources in the destructor

This ensures that resources are properly managed, even if exceptions occur.


## How RAII Prevents Dangling Pointers


RAII can prevent dangling pointers by ensuring that objects are destroyed (and their resources released) at the right time. Here's an example:


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

class Resource {
public:
  Resource(){
    std::cout << "Resource acquired\n";
  }

  ~Resource(){
    std::cout << "Resource released\n";
  }

  void use(){ std::cout << "Resource used\n"; }
};

class ResourceManager {
  std::unique_ptr<Resource> resource;

public:
  ResourceManager()
    : resource(std::make_unique<Resource>()){}

  Resource* get(){ return resource.get(); }
};

void useResource(){
  ResourceManager manager;
  Resource* ptr = manager.get();
  ptr->use();
} // ResourceManager is destroyed here,
// which destroys the Resource

int main(){ useResource(); }
```


```plain text
//<o>
Resource acquired
Resource used
Resource released
```


In this example, `ResourceManager` owns the `Resource`. When `ResourceManager` goes out of scope, it automatically destroys the `Resource`, preventing any dangling pointers.


## RAII and Smart Pointers


Smart pointers like `std::unique_ptr` and `std::shared_ptr` implement RAII:


```c++
#include <memory>

void useResource() {
  auto resource = std::make_unique<Resource>();
  resource->use();
} // resource is automatically deleted here

int main() { useResource(); }
```


This code ensures that the `Resource` is properly deleted, even if an exception is thrown.


## RAII vs Manual Resource Management


Without RAII, you might write code like this:


```c++
#include <iostream>

class Resource {
public:
  Resource(){
    std::cout << "Resource acquired\n";
  }

  ~Resource(){
    std::cout << "Resource released\n";
  }

  void use(){ std::cout << "Resource used\n"; }
};

void useResource(){
  auto ptr = new Resource(); //<w>
  ptr->use();
  delete ptr; //<w>
}

int main(){ useResource(); }
```


```plain text
//<o>
Resource acquired
Resource used
Resource released
```


This approach is prone to errors:

- If an exception occurs after `new` but before `delete`, the resource leaks.
- If you forget to call `delete`, you get a memory leak.
- If you accidentally use `ptr` after `delete`, you have a dangling pointer.

RAII solves these problems by tying the resource's lifetime to an object's lifetime.


In conclusion, RAII is a powerful tool for preventing dangling pointers and other resource management issues. By ensuring that resources are tied to object lifetimes, RAII makes it much harder to accidentally create dangling pointers or leak resources.

Dangling Pointers and RAII

Yes, several design patterns can help prevent dangling pointer issues in C++. Let's explore some of the most effective ones:


## 1. RAII (Resource Acquisition Is Initialization)


While not strictly a design pattern, RAII is a fundamental C++ idiom that helps prevent resource leaks and dangling pointers:


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

class Resource {
public:
  Resource(){
    std::cout << "Resource acquired\n";
  }

  ~Resource(){
    std::cout << "Resource released\n";
  }
};

class RAIIWrapper {
  std::unique_ptr<Resource> ptr;

public:
  RAIIWrapper() : ptr(
    std::make_unique<Resource>()){}

  // Resource is automatically released when
  // RAIIWrapper is destroyed
};

void useResource(){
  RAIIWrapper wrapper;
  // Use the resource...
} // Resource is automatically released here
```


## 2. Factory Method


The Factory Method pattern can be used to ensure proper object creation and lifetime management:


```c++
#include <memory>

class Product {
public:
  virtual ~Product() = default;
  virtual void use() = 0;
};

class ConcreteProduct : public Product {
public:
  void use() override{
    /* ... */
  }
};

class Creator {
public:
  virtual std::unique_ptr<Product>
    createProduct() = 0;
};

class ConcreteCreator : public Creator {
public:
  std::unique_ptr<Product>
  createProduct() override{
    return std::make_unique<ConcreteProduct>();
  }
};
```


This pattern ensures that object creation is centralized and can be easily managed.


## 3. Singleton


The Singleton pattern, when implemented correctly, can prevent dangling pointers by ensuring only one instance of an object exists:


```c++
class Singleton {
public:
  static Singleton& getInstance(){
    static Singleton instance;
    return instance;
  }

  Singleton(const Singleton&) = delete;
  Singleton& operator=(const Singleton&)
  = delete;

private:
  Singleton() = default;
};
```


This implementation uses the "magic static" feature of C++11 to ensure thread-safe initialization.


## 4. Observer


The Observer pattern can be implemented using smart pointers to prevent dangling pointers:


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

class Observer {
public:
  virtual ~Observer() = default;
  virtual void
    update() = 0;
};

class Subject {
  std::vector<std::weak_ptr<Observer>>
    observers;

public:
  void addObserver(
    std::shared_ptr<Observer> observer){
    observers.push_back(observer);
  }

  void notify(){
    for (auto it = observers.begin();
         it != observers.end();) {
      if (auto observer = it->lock()) {
        observer->update();
        ++it;
      } else {
        // Remove expired observers
        it = observers.erase(it);
      }
    }
  }
};
```


Using `std::weak_ptr` prevents circular references and allows automatic cleanup of expired observers.


## 5. Pimpl (Pointer to Implementation)


The Pimpl idiom can help manage object lifetimes and prevent exposure of pointers:


```c++
// In header file
class Widget {
  class Impl;
  std::unique_ptr<Impl> pImpl;

 public:
  Widget();
  ~Widget();
  void doSomething();
};
```


```c++
// In source file
class Widget::Impl {
public:
  void doSomething(){
    /* ... */
  }
};

Widget::Widget() : pImpl(
  std::make_unique<Impl>()){}

Widget::~Widget() = default;

void Widget::doSomething(){
  pImpl->doSomething();
}
```


This pattern hides the implementation details and manages the lifetime of the implementation object.


Remember, while these patterns can help prevent dangling pointer issues, they're not silver bullets. Good coding practices, careful design, and thorough testing are still essential for writing safe and efficient C++ code.

Design Patterns to Prevent Dangling Pointers

Returning pointers or references from functions can lead to dangling pointer issues if not handled carefully. Fortunately, C++ provides several safer alternatives. Let's explore some of these options:


## 1. Return by Value


The simplest and often safest approach is to return objects by value:


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

std::string createGreeting(
  const std::string& name
){
  return "Hello, " + name + "!";
}

int main(){
  std::string greeting =
    createGreeting("Alice");
  std::cout << greeting;
}
```


```plain text
//<o>
Hello, Alice!
```


Modern C++ compilers are good at optimizing this, often using Return Value Optimization (RVO) to avoid unnecessary copies.


## 2. Optional Types


When you need to represent the possibility of no value, use `std::optional`:


```c++
#include <optional>
#include <string>
#include <iostream>

std::optional<std::string> findUser(int id) {
  if (id == 1) { return "Alice"; }
  return std::nullopt;
}

int main() {
  auto user = findUser(1);
  if (user) {
    std::cout << "Found user: " << *user << '\n';
  } else { std::cout << "User not found\n"; }
}
```


```plain text
//<o>
Found user: Alice
```


## 3. Smart Pointers


When dynamic allocation is necessary, use smart pointers:


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

std::unique_ptr<int> createNumber() {
  return std::make_unique<int>(42);
}

int main() {
  auto ptr = createNumber();
  std::cout << "The number is: " << *ptr;
}
```


```plain text
//<o>
The number is: 42
```


`std::unique_ptr` ensures the object is properly deleted when it's no longer needed.


## 4. Output Parameters


You can use output parameters to return multiple values:


```c++
#include <iostream>

void getMinMax(
  const int* arr, size_t size,
  int& min, int& max
){
  if (size == 0) return;
  min = max = arr[0];
  for (size_t i = 1; i < size; ++i) {
    if (arr[i] < min) min = arr[i];
    if (arr[i] > max) max = arr[i];
  }
}

int main(){
  int arr[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
  int min, max;
  getMinMax(arr, std::size(arr), min, max);
  std::cout << "Min: " << min << ", Max: "
    << max;
}
```


```plain text
//<o>
Min: 1, Max: 9
```


## 5. Structured Binding (C++17)


Structured binding allows you to return multiple values easily:


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

std::tuple<int, int> getMinMax(
  const int* arr, size_t size
){
  if (size == 0) return {0, 0};
  int min = arr[0], max = arr[0];
  for (size_t i = 1; i < size; ++i) {
    if (arr[i] < min) min = arr[i];
    if (arr[i] > max) max = arr[i];
  }
  return {min, max};
}

int main(){
  int arr[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
  auto [min, max] = getMinMax(
    arr, std::size(arr));
  std::cout << "Min: " << min << ", Max: "
    << max;
}
```


```plain text
//<o>
Min: 1, Max: 9
```


## 6. `std::pair` or `std::tuple`


For returning two or more values:


```c++
#include <utility>
#include <string>
#include <iostream>

std::pair<std::string, int> getNameAndAge(){
  return {"Alice", 30};
}

int main(){
  auto [name, age] = getNameAndAge();
  std::cout << name << " is " << age <<
    " years old";
}
```


```plain text
//<o>
Alice is 30 years old
```


These alternatives provide safer and more expressive ways to return data from functions without risking dangling pointers. Choose the most appropriate option based on your specific use case and the semantics you want to convey.

Alternatives to Returning Pointers

<Excerpt>


Now that we're working with pointers and references, we need to talk briefly about memory management.


This is a large topic - we have a full chapter dedicated to it later in the course.  For now, we just need to understand an important consideration when we're using references or pointers to objects created in our functions.


Let's demonstrate the problem with a simple program:


</Excerpt>


```c++
#include <iostream>
using namespace std;

int* GetNumber(){
  int Number{1};
  return &Number;
}

int main(){
  int* Result{GetNumber()};
  cout << "Result: " << *Result;
}
```


We might expect this to log out `1`, but that is not the case:


```c++
//<o>
Result: -858993460
```


The compiler should give us a warning that we might have been doing something wrong on our `return` statement:


```c++
//<oe>
Address of stack memory associated with local variable Number returned
```


Let's take some time to understand what's going on here, as it's a very common error that beginners make.


<Ad />


## Stack Memory


In the introductory lessons, we covered the idea of the **stack**, and how our functions each create stack frames.


<LessonPromo url="intro-to-programming/debugging-functions" title="The Call Stack and Debugging Functions" description="An introduction to how our function calls create a call stack, and how we can navigate it in a debugger." />


Stack frames are a form of memory management.


The parameters and local variables that our functions create are stored within these stack frames.


Within our call to `GetNumber()`, we are allocated memory to store the `int` we created.  We then returned that memory address to our `main` function:


<Img multiply hasTransparency file="returningPointerFixed.png" width="751" height="285" alt="Diagram showing the return of a pointer from a function" blurHash="L6R:HH00~pIUoJD*Rjj[odIURit7" />


However, when the `GetNumber()` function ends, its stack frame, and all the objects stored within it, are destroyed.  This includes the `Number` variable.  We're returning a pointer to that variable, meaning we're returning a pointer to a variable that no longer exists.


We can see this by using a custom type with a destructor:


```c++
#include <iostream>
using namespace std;

struct SomeType {
  int Value{1};
  ~SomeType(){ cout << "Destroying\n"; }
};

SomeType* GetObject(){
  SomeType SomeObject;
  return &SomeObject;
}

int main(){
  SomeType* Result{GetObject()};
  cout << "Result: " << Result->Value;
}
```


```c++
//<o>
Destroying
Result: -858993460
```


## What Are Dangling Pointers and References?


When we have a pointer or reference to an object, and that object is then deleted, the pointer is no longer useful.  It is sometimes referred to as a _**dangling pointer**_ or _**dangling reference**_.


If we attempt to use a dangling pointer or reference, our program's behavior becomes unpredictable.  This often results in a crash or other serious issues like security vulnerabilities.


This is because the memory our object was using is freed up for other purposes, meaning we no longer know what will be stored there by the time we use our pointer or reference.


<Img multiply hasTransparency file="danglingPointerFixed.png" width="751" height="285" alt="Diagram showing a dangling pointer" blurHash="L7SF;M9F~qM{?bWCayt7xuM|M{t7" />


<Aside>


### Why This Only Applies to References and Pointers


Previously, we've been creating and returning local variables by value without issues. When we return a value from a function, that value is copied or moved to the calling function's stack frame, or another appropriate location.


When the thing we returned was the value, everything worked as expected.


However, when a pointer (or reference) is returned, that pointer can refer to a memory location that is about to be freed.  When that pointer is then used, unpredictable things can happen, as the first example demonstrated.


</Aside>


## Storage Durations


In C++, objects have different lifetimes depending on how they're created. This concept is known as _**storage duration**_. The local variables we've been using in functions have what's called _**automatic storage duration**_ - they're automatically created when the function is called and destroyed when it ends.


However, there are other storage durations in C++:

1. Static storage duration: Objects exist for the entire run of the program.
2. Thread storage duration: Each thread has its own copy of the object.
3. Dynamic storage duration: The programmer controls when objects are created and destroyed.

For now, we're primarily concerned with automatic storage duration and its implications. When we need an object to last longer than a single function call, we have several options:

- Create it in the global scope (though this should be used sparingly)
- Create it inside the `main` function
- Make it part of a longer-lived object

Later in the course, we'll cover memory management in more detail, and learn how to control object lifetimes more precisely. This will include techniques for dynamic allocation and smart pointers, which give us more flexibility in managing object lifetimes.


## Summary


In this lesson, we briefly introduced the concept of storage durations, and how memory allocated on the stack is automatically freed when the stack frame is destroyed.


In particular, we covered the implications this has for objects returned by pointer or reference from functions, and how improper usage can cause memory problems.


<Preview>


### Polymorphism


In the next chapter, we introduce polymorphism - a key technique that lets us ramp up the complexity of our program, without necessarily making our code more complex.  We'll cover:

- **Introduction to Polymorphism**: Defining polymorphism in the context of C++ programming and its importance in creating flexible, reusable code.
- **Types of Polymorphism**: Discussing the different types, such as compile-time (overloading) and runtime polymorphism (virtual functions).
- **Function Overloading**: Covering how functions can be overloaded to implement different behaviors depending on the data type they are called with.
- **Virtual Functions and Inheritance**: Exploring how virtual functions enable runtime polymorphism through inheritance hierarchies.
- **Best Practices and Common Pitfalls**: Highlighting best practices in implementing polymorphism and common mistakes to avoid.
- **Case Studies and Examples**: Including real-world examples and case studies to demonstrate the use of polymorphism in various scenarios.

</Preview>

Reorganized course to move memory management lessons later

Abstract art representing computer programming

Object Lifetime

Automatic storage duration

{CPP}Dive into C++ with our beginner-friendly guide on handling pointers and references to ensure error-free code

{CPP}C++ Guide: Avoiding Dangling Pointers & References

What Are Dangling Pointers and References?

Why This Only Applies to References and Pointers

Dangling Pointers and References

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers