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

Storing polymorphic types in a `std::vector` is a common requirement when working with class hierarchies. However, it requires some special considerations due to object slicing and memory management. Let's explore how to do this correctly using pointers or smart pointers.


## Using Raw Pointers


The simplest way to store polymorphic types is using raw pointers:


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

class Character {
public:
  virtual void speak() const = 0;
  virtual ~Character() = default;
};

class Warrior : public Character {
public:
  void speak() const override{
    std::cout << "I am a warrior!\n";
  }
};

class Mage : public Character {
public:
  void speak() const override{
    std::cout << "I am a mage!\n";
  }
};

int main(){
  std::vector<Character*> characters;

  characters.push_back(new Warrior());
  characters.push_back(new Mage());

  for (const auto& character : characters) {
    character->speak();
  }

  // Don't forget to delete!
  for (auto character : characters) {
    delete character;
  }
}
```


```plain text
//<o>
I am a warrior!
I am a mage!
```


However, this approach requires manual memory management, which can lead to memory leaks if not handled correctly.


## Using Smart Pointers


A better approach is to use smart pointers, particularly `std::unique_ptr` or `std::shared_ptr`:


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

class Character {
public:
  virtual void speak() const = 0;
  virtual ~Character() = default;
};

class Warrior : public Character {
public:
  void speak() const override{
    std::cout << "I am a warrior!\n";
  }
};

class Mage : public Character {
public:
  void speak() const override{
    std::cout << "I am a mage!\n";
  }
};

int main(){
  std::vector<std::unique_ptr<Character>>
    characters;

  characters.push_back(
    std::make_unique<Warrior>());
  characters.
    push_back(std::make_unique<Mage>());

  for (const auto& character : characters) {
    character->speak();
  }

  // No need to manually delete
}
```


```plain text
//<o>
I am a warrior!
I am a mage!
```


This approach is safer as it automatically manages memory, preventing leaks.


Remember, when using polymorphic types, always declare the base class destructor as virtual to ensure proper cleanup of derived classes.


By using these techniques, you can effectively store and manage polymorphic types in a `std::vector`, allowing for flexible and type-safe operations on collections of objects with different derived types.

Storing Polymorphic Types in `std::vector`

Removing objects from a `std::vector` is a common operation, and C++ provides several ways to do this depending on your specific needs. Let's explore the main approaches.


## Using `erase()`


The `erase()` function is the most straightforward way to remove elements from a `std::vector`. It can remove a single element or a range of elements:


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

int main(){
  std::vector<int> numbers{1, 2, 3, 4, 5};

  // Remove the third element (index 2)
  numbers.erase(numbers.begin() + 2); //<h>

  // Print the vector
  for (int num : numbers) {
    std::cout << num << ' ';
  }
  std::cout << '\n';

  // Remove a range (first two elements)
  numbers.erase( //<h>
    numbers.begin(), //<h>
    numbers.begin() + 2); //<h>

  // Print the vector again
  for (int num : numbers) {
    std::cout << num << ' ';
  }
}
```


```plain text
//<o>
1 2 4 5
4 5
```


## Using `remove()` and `erase()`


For more complex removal conditions, you can use the `remove()` algorithm along with `erase()`. This is known as the erase-remove idiom:


```c++
#include <iostream>
#include <vector>
#include <algorithm>

int main(){
  std::vector<int> numbers{
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

  // Remove all even numbers
  numbers.erase(
    std::remove_if(
      numbers.begin(), numbers.end(),
      [](int n){ return n % 2 == 0; }), //<h>
    numbers.end());

  // Print the vector
  for (int num : numbers) {
    std::cout << num << ' ';
  }
}
```


```plain text
//<o>
1 3 5 7 9
```


## Using `pop_back()`


If you only need to remove the last element, use `pop_back()`:


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

int main(){
  std::vector<int> numbers{1, 2, 3, 4, 5};

  numbers.pop_back(); //<h>

  // Print the vector
  for (int num : numbers) {
    std::cout << num << ' ';
  }
}
```


```plain text
//<o>
1 2 3 4
```


Remember that removing elements from the middle of a `std::vector` can be expensive, as it requires shifting all subsequent elements. If you frequently need to remove elements from arbitrary positions, consider using `std::list` instead.


Also, be cautious when removing elements while iterating over a vector. Removing an element invalidates iterators at or after the point of removal. Here's a safe way to remove elements while iterating:


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

int main(){
  std::vector<int> numbers{
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

  for (auto it = numbers.begin();
    it != numbers.end();) {
    if (*it % 2 == 0) {
      it = numbers.erase(it); //<h>
    } else { ++it; }
  }

  // Print the vector
  for (int num : numbers) {
    std::cout << num << ' ';
  }
}
```


```plain text
//<o>
1 3 5 7 9
```


By using these techniques, you can effectively remove objects from a `std::vector` in various scenarios, whether you're removing single elements, ranges, or elements that meet specific criteria.

Removing Objects from `std::vector`

Removing elements from the middle of a `std::vector` can be done using the `erase()` function. However, it's important to understand the performance implications and some best practices.


## Using `erase()`


The `erase()` function removes an element at a specific position or a range of elements. Here's how you can use it:


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

int main(){
  std::vector<int> numbers{1, 2, 3, 4, 5};

  // Remove the element at index 2
  // (the third element)
  numbers.erase(numbers.begin() + 2); //<h>

  for (int num : numbers) {
    std::cout << num << ' ';
  }
}
```


```plain text
//<o>
1 2 4 5
```


## Performance Considerations


When you remove an element from the middle of a `std::vector`, all elements after the removed element need to be shifted to fill the gap. This operation has a time complexity of $O(n)$, where $n$ is the number of elements after the removal point.


If you need to remove multiple elements, it's more efficient to remove them in a single operation:


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

int main(){
  std::vector<int> numbers{
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

  // Remove objects from index 2 to 5 (inclusive)
  numbers.erase(numbers.begin() + 2, //<h>
                numbers.begin() + 6); //<h>

  for (int num : numbers) {
    std::cout << num << ' ';
  }
}
```


```plain text
//<o>
1 2 7 8 9 10
```


## Efficient Removal of Multiple Elements


If you need to remove multiple elements that don't form a contiguous range, consider using the erase-remove idiom:


```c++
#include <iostream>
#include <vector>
#include <algorithm>

int main(){
  std::vector<int> numbers{
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

  // Remove all even numbers
  numbers.erase(
    std::remove_if(
      numbers.begin(), numbers.end(),
      [](int n){ return n % 2 == 0; }), //<h>
    numbers.end());

  for (int num : numbers) {
    std::cout << num << ' ';
  }
}
```


```plain text
//<o>
1 3 5 7 9
```


This approach is more efficient as it only performs one pass through the vector, moving elements that should be kept to the front.


Remember, if you frequently need to remove elements from the middle of a container, `std::vector` might not be the best choice. Consider using `std::list` or `std::deque` for such scenarios, as they offer more efficient insertion and deletion in the middle.

Removing Elements from the Middle of a Vector

A circular buffer, also known as a ring buffer, is a fixed-size buffer that wraps around when it reaches its end. It's particularly useful for scenarios like buffering data streams or implementing a queue with a fixed maximum size. Let's implement a simple circular buffer using `std::vector`.


## Basic Implementation


Here's a basic implementation of a circular buffer:


```c++
// CircularBuffer.h
#pragma once
#include <vector>
#include <stdexcept>

template <typename T>
class CircularBuffer {
public:
  CircularBuffer(size_t size)
    : buffer(size), max_size(size){}

  void push(const T& item){
    buffer[head] = item;
    if (full) { tail = (tail + 1) % max_size; }
    head = (head + 1) % max_size;
    full = head == tail;
  }

  T pop(){
    if (empty()) {
      throw std::runtime_error(
        "Buffer is empty");
    }
    T item = buffer[tail];
    full = false;
    tail = (tail + 1) % max_size;
    return item;
  }

  bool empty() const{
    return (!full && (head == tail));
  }

  size_t size() const{
    if (full) { return max_size; }
    if (head >= tail) { return head - tail; }
    return max_size + head - tail;
  }
  
  bool full = false;

private:
  std::vector<T> buffer;
  size_t head = 0;
  // Points to the next write position
  size_t tail = 0;
  // Points to the oldest element
  size_t max_size;
};
```


## Using the Circular Buffer


Now let's see how we can use this circular buffer:


```c++
#include <iostream>
#include "CircularBufer.h"

int main(){
  CircularBuffer<int> buffer(5);

  // Fill the buffer
  for (int i = 1; i <= 5; ++i) {
    buffer.push(i);
  }

  std::cout << "Buffer full? "
    << (buffer.full ? "Yes" : "No") << '\n';
  std::cout << "Buffer size: " << buffer.size()
    << '\n';

  // Overwrite some values
  buffer.push(6);
  buffer.push(7);

  // Pop and print all values
  while (!buffer.empty()) {
    std::cout << buffer.pop() << ' ';
  }
  std::cout << '\n';

  std::cout << "Buffer empty? "
    << (buffer.empty() ? "Yes" : "No") << '\n';
}
```


```plain text
//<o>
Buffer full? Yes
Buffer size: 5
3 4 5 6 7
Buffer empty? Yes
```


In this example, we create a circular buffer of size 5. We fill it with numbers 1 to 5, then add 6 and 7, which overwrite 1 and 2. When we pop all elements, we get 3, 4, 5, 6, 7 in that order.


This implementation uses `std::vector` as the underlying container, which provides contiguous memory storage and efficient random access. The `head` and `tail` indices wrap around using the modulo operator, creating the circular behavior.


Remember, this is a basic implementation and could be extended with additional features like iterators, capacity changes, or thread safety, depending on your specific needs.

Implementing a Circular Buffer with Vector

Yes, you can use `std::vector` with move-only types like `std::unique_ptr`. However, there are some important considerations and best practices to keep in mind.


## Basic Usage


Here's a simple example of using `std::vector` with `std::unique_ptr`:


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

class Resource {
public:
  Resource(int id) : id(id){
    std::cout << "Resource " << id <<
      " created\n";
  }

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

  int getId() const{ return id; }

private:
  int id;
};

int main(){
  std::vector<std::unique_ptr<Resource>>
    resources;

  // Adding elements
  resources.push_back(
    std::make_unique<Resource>(1)); //<h>
  resources.emplace_back(
    std::make_unique<Resource>(
      2)); //<h>// Accessing elements
  for (const auto& resource : resources) {
    std::cout << "Resource ID: "
      << resource->getId() << '\n';
  }

  // Vector will automatically delete the 
  // Resources when it goes out of scope
}
```


```plain text
//<o>
Resource 1 created
Resource 2 created
Resource ID: 1
Resource ID: 2
Resource 2 destroyed
Resource 1 destroyed
```


## Considerations

1. **Use** **`std::move()`** **with the** **`emplace_back()`** **or** **`push_back()`** **methods:** Since `std::unique_ptr` is move-only, you need to use `emplace_back()` or `push_back()` with `std::move()` to add elements.
2. **Avoid copy operations**: `std::vector` may need to reallocate and move its elements when it grows. Ensure your move-only types have efficient move constructors and move assignment operators.
3. **Be cautious with reallocation**: When `std::vector` reallocates, it moves all its elements. This is fine for `std::unique_ptr`, but could be problematic for other move-only types that have side effects when moved.
4. **Be careful with algorithms**: Some standard algorithms may not work with move-only types. Always check the requirements of algorithms you plan to use.

Additionally, to minimize reallocations, consider using `reserve()` if you know how many elements you'll be adding:


```c++
std::vector<std::unique_ptr<Resource>> resources;

// Prepare space for 10 elements
resources.reserve(10);
```


## Example with Custom Move-Only Type


Here's an example with a custom move-only type:


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

class MoveOnlyType {
public:
  MoveOnlyType(int value) : value(value){
    std::cout << "MoveOnlyType " << value <<
      " created\n";
  }

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

  MoveOnlyType(MoveOnlyType&& other) noexcept
    : value(other.value){
    std::cout << "MoveOnlyType " << value <<
      " moved\n";
    other.value = 0;
  }

  MoveOnlyType& operator=(
    MoveOnlyType&& other) noexcept{
    if (this != &other) {
      value = other.value;
      other.value = 0;
      std::cout << "MoveOnlyType " << value
        << " move assigned\n";
    }
    return *this;
  }

  ~MoveOnlyType(){
    std::cout << "MoveOnlyType " << value <<
      " destroyed\n";
  }

  int getValue() const{ return value; }

private:
  int value;
};

int main(){
  std::vector<MoveOnlyType> vec;
  vec.reserve(3);
  // Avoid reallocation for this example

  vec.push_back(MoveOnlyType(1));
  vec.emplace_back(2);
  vec.push_back(std::move(MoveOnlyType(3)));

  for (const auto& item : vec) {
    std::cout << "Value: " << item.getValue() <<
      '\n';
  }
}
```


```plain text
//<o>
MoveOnlyType 1 created
MoveOnlyType 1 moved
MoveOnlyType 0 destroyed
MoveOnlyType 2 created
MoveOnlyType 3 created
MoveOnlyType 3 moved
MoveOnlyType 0 destroyed
Value: 1
Value: 2
Value: 3
MoveOnlyType 1 destroyed
MoveOnlyType 2 destroyed
MoveOnlyType 3 destroyed
```


This example demonstrates creating, moving, and destroying move-only objects within a `std::vector`. Understanding these concepts is crucial when working with move-only types in containers like `std::vector`.

Using Vector with Move-Only Types

Accessing `std::vector` elements in a multithreaded environment requires careful consideration to avoid data races and ensure thread safety. Here are some strategies and best practices:


## Use of Mutex


The most common approach is to use a mutex to synchronize access to the vector:


```c++
#include <iostream>
#include <vector>
#include <mutex>
#include <thread>

class ThreadSafeVector {
private:
  std::vector<int> vec;
  mutable std::mutex mutex;

public:
  void push_back(int value){
    std::lock_guard<std::mutex> lock(mutex);
    vec.push_back(value);
  }

  int at(size_t index) const{
    std::lock_guard<std::mutex> lock(mutex);
    return vec.at(index);
  }

  size_t size() const{
    std::lock_guard<std::mutex> lock(mutex);
    return vec.size();
  }
};

void writer(ThreadSafeVector& tsv){
  for (int i = 0; i < 1000; ++i) {
    tsv.push_back(i);
  }
}

void reader(const ThreadSafeVector& tsv){
  for (int i = 0; i < 1000; ++i) {
    if (i < tsv.size()) {
      std::cout << tsv.at(i) << " ";
    }
  }
}

int main(){
  ThreadSafeVector tsv;
  std::thread t1(writer, std::ref(tsv));
  std::thread t2(reader, std::ref(tsv));
  t1.join();
  t2.join();
}
```


```plain text
//<o>
1 2 3 4 ...
```


In this example, all accesses to the vector are protected by a mutex, ensuring that only one thread can access the vector at a time.


## Read-Write Lock


If you have many readers and few writers, consider using a read-write lock (`std::shared_mutex` in C++17):


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

class ThreadSafeVector {
private:
  std::vector<int> vec;
  mutable std::shared_mutex mutex;

public:
  void push_back(int value){
    std::unique_lock<std::shared_mutex> lock(
      mutex);
    vec.push_back(value);
  }

  int at(size_t index) const{
    std::shared_lock<std::shared_mutex> lock(
      mutex);
    return vec.at(index);
  }
};
```


This allows multiple threads to read simultaneously, but ensures exclusive access for writing.


## Copy-on-Write


For read-heavy scenarios, you might consider a copy-on-write approach:


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

class ThreadSafeVector {
private:
  std::shared_ptr<std::vector<int>> vec;
  mutable std::mutex mutex;

public:
  ThreadSafeVector()
    : vec(
      std::make_shared<std::vector<int>>()){}

  void push_back(int value){
    std::lock_guard<std::mutex> lock(mutex);
    if (vec.use_count() > 0) {
      vec = std::make_shared<std::vector<
        int>>(*vec);
    }
    vec->push_back(value);
  }

  std::vector<int> get_copy() const{
    std::lock_guard<std::mutex> lock(mutex);
    return *vec;
  }
};
```


This approach creates a new copy of the vector only when a write operation occurs and there are other references to the current vector.


## Considerations

1. **Performance**: Locking can impact performance, especially in high-concurrency scenarios.
2. **Granularity**: Consider the granularity of your locks. Locking the entire vector for each operation might be overkill if you only need to protect specific elements.
3. **Deadlocks**: Be careful to avoid deadlocks when using multiple locks.
4. **Consistency**: Ensure that related operations maintain consistency. For example, checking `size()` and then accessing an element isn't atomic without proper synchronization.
5. **Alternative Containers**: Consider using containers designed for concurrent access, like `tbb::concurrent_vector` from Intel's Threading Building Blocks library, if you need high-performance concurrent access.
6. **Lock-free Algorithms**: In some cases, you might be able to use lock-free algorithms for better performance, but these can be complex to implement correctly.

Remember, thread safety often comes at the cost of performance. Always profile your application to ensure that your thread-safety measures aren't causing unacceptable performance bottlenecks.

Thread Safety with `std::vector`

Using `std::vector` to implement a 2D grid or matrix is a common and efficient way to handle two-dimensional data in C++. There are primarily two approaches: using a vector of vectors, or using a single vector with custom indexing.


## Approach 1: Vector of Vectors


This is the most straightforward approach, where we create a vector of vector elements:


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

class Grid {
private:
  std::vector<std::vector<int>> data;
  size_t rows, cols;

public:
  Grid(size_t r, size_t c)
    : rows(r), cols(c),
      data(r, std::vector<int>(c, 0)){}

  int& at(size_t r, size_t c){
    return data[r][c];
  }

  const int& at(size_t r, size_t c) const{
    return data[r][c];
  }

  void print() const{
    for (const auto& row : data) {
      for (int val : row) {
        std::cout << val << ' ';
      }
      std::cout << '\n';
    }
  }
};

int main(){
  Grid grid(3, 4);

  // Set some values
  grid.at(0, 0) = 1;
  grid.at(1, 2) = 5;
  grid.at(2, 3) = 9;

  // Print the grid
  grid.print();
}
```


```plain text
//<o>
1 0 0 0
0 0 5 0
0 0 0 9
```


This approach is intuitive and allows for rows of different lengths if needed. However, it may have slightly more overhead due to multiple allocations.


## Approach 2: Single Vector with Custom Indexing


This approach uses a single vector to store all elements, which can be more efficient:


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

class Grid {
private:
  std::vector<int> data;
  size_t rows, cols;

public:
  Grid(size_t r, size_t c)
    : rows(r), cols(c), data(r * c, 0){}

  int& at(size_t r, size_t c){
    return data[r * cols + c];
  }

  const int& at(size_t r, size_t c) const{
    return data[r * cols + c];
  }

  void print() const{
    for (size_t i = 0; i < rows; ++i) {
      for (size_t j = 0; j < cols; ++j) {
        std::cout << at(i, j) << ' ';
      }
      std::cout << '\n';
    }
  }
};

int main(){
  Grid grid(3, 4);

  // Set some values
  grid.at(0, 0) = 1;
  grid.at(1, 2) = 5;
  grid.at(2, 3) = 9;

  // Print the grid
  grid.print();
}
```


```plain text
//<o>
1 0 0 0
0 0 5 0
0 0 0 9
```


This approach uses a single allocation and can be more cache-friendly, potentially offering better performance for large grids.


## Advanced Features


You can extend either approach with more advanced features:


### Range Checking


Add bounds checking in the `at()` function:


```c++
int& at(size_t r, size_t c){
  if (r >= rows || c >= cols) {
    throw std::out_of_range(
      "Grid indices out of range");
  }
  return data[r * cols + c];
}
```


### Iterators


Implement custom iterators for row-wise or column-wise traversal.


### Resizing


Add functions to resize the grid:


```c++
void resize(size_t new_rows, size_t new_cols){
  std::vector<int> new_data(
    new_rows * new_cols, 0);
  for (size_t i = 0; i <
       std::min(rows, new_rows); ++i) {
    for (size_t j = 0; j <
         std::min(cols, new_cols); ++j) {
      new_data[i * new_cols + j] = at(i, j);
    }
  }
  data = std::move(new_data);
  rows = new_rows;
  cols = new_cols;
}
```


### Operations


Implement mathematical operations like matrix addition or multiplication.


Remember, the choice between these approaches depends on your specific use case. The vector of vectors is more flexible but might be slightly slower, while the single vector approach is generally faster but less flexible for non-rectangular grids.

Using Vector for a 2D Grid

Added section on `capacity()` and `reserve()`

Moved lesson earlier in the course and updated content

Reorganized course to move memory management lessons later

Minor content refresh and added section on `erase()`

Abstract art representing computer programming

Array (data structure)

std::vector - Detailed Overview

Questions tagged [stdvector]

C++ Vectors and Their Usage

Vector in C++ STL

Introduction to std::vector and list constructors

C++ Vectors

C++ - Vectors

{CPP}Learn the basics of dynamic arrays in C++ with our introduction to std::vector

{CPP}Master Dynamic Arrays with std::vector

Constructing Objects using `emplace_back()`

Comparing Array `size()` and `capacity()`

Dynamic Arrays using `std::vector`

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers

Dynamic Arrays using std::vector

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Questions & Answers

Dynamic Arrays using `std::vector`