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

Ensuring consistency between your copy constructor and copy assignment operator is crucial for predictable behavior in your C++ classes. Here are some key points to keep in mind:


## Shared Logic


The most straightforward way to ensure consistency is to share logic between the two operations. You can do this by having one operation call the other, or by extracting the common logic into a separate private method.


For example, you could implement the copy assignment operator in terms of the copy constructor:


```c++
#include <memory>

class Player {
public:
  Player(const Player& other)
    : weapon(
      std::make_unique<Weapon>(*other.weapon)) {
    // Copy constructor logic
  }

  Player& operator=(const Player& other) {
    if (this != &other) {
      // Create a temporary copy
      Player temp(other);
      
      // Swap contents with the☺ temporary
      std::swap(*this, temp);
    }
    return *this;
  }

private:
  std::unique_ptr<Weapon> weapon;
};
```


This approach, known as the copy-and-swap idiom, ensures that the copy assignment operator behaves consistently with the copy constructor.


## Resource Management


Both operations should handle resource management in the same way. If your copy constructor performs a deep copy of resources, your copy assignment operator should do the same.


## Exception Safety


Ensure both operations provide the same level of exception safety. If one operation can throw exceptions, the other should handle similar scenarios gracefully.


## Testing


Thoroughly test both operations to ensure they behave identically in various scenarios. Write unit tests that copy objects both ways and verify the results.


By following these principles, you can maintain consistency between your copy constructor and copy assignment operator, leading to more reliable and predictable code.

Ensuring Consistency in Copy Operations

In C++, we return a reference to the object in the copy assignment operator for several important reasons:


## Chaining Assignments


Returning a reference allows for chaining of assignment operations. Consider this example:


```c++
#include <iostream>

class Player {
public:
  Player& operator=(const Player& other) {
    // Copy logic here
    std::cout << "Copying player\n";
    return *this;
  }
};

int main() {
  Player p1, p2, p3;
  p1 = p2 = p3; // Chained assignment
}
```


```plain text
//<o>
Copying player
Copying player
```


Here, `p2 = p3` is executed first, then its result (a reference to `p2`) is used for `p1 = p2`.


## Consistency with Built-in Types


Returning a reference makes the behavior consistent with built-in types. For example:


```c++
int a, b, c;
(a = b) = c;// This is valid for built-in types
```


## Efficiency


Returning by reference is more efficient than returning by value, as it avoids unnecessary copying of the object.


## Enabling Expression Evaluation


Returning a reference allows the assignment to be part of a larger expression:


```c++
#include <iostream>

class Player {
public:
  Player& operator=(const Player& other) {
    // Copy logic here
    return *this;
  }
};

int main() {
  Player p1, p2;
  // Assignment as part of condition
  if ((p1 = p2).isValid()) {
    std::cout << "Valid player\n";
  }
}
```


Here, we can use the result of the assignment directly in the `if` condition.


Remember, while returning a reference is the convention and generally the best practice, the language doesn't strictly require it. However, following this convention makes your code more intuitive and consistent with standard C++ practices.

Returning References in Copy Assignment

Copy constructors and assignment operators interact with inheritance in C++ in several important ways. Understanding these interactions is crucial for correctly implementing copying behavior in class hierarchies.


## Base Class Copying


When you create a copy constructor or copy assignment operator for a derived class, it's important to ensure that the base class part of the object is also correctly copied. This isn't done automatically.


For copy constructors, you need to explicitly call the base class copy constructor:


```c++
#include <iostream>

class Actor {
public:
  Actor() = default;
  Actor(const Actor& other) {
    std::cout << "Copying Actor\n";
  }
};

class Player : public Actor {
 public:
  Player() = default;
  Player(const Player& other)
     // Explicitly copy base class part
      : Actor(other) {  //<h>
    std::cout << "Copying Player\n";
  }
};

int main() {
  Player p1;
  Player p2(p1);
}
```


```plain text
//<o>
Copying Actor
Copying Player
```


For copy assignment operators, you need to assign the base class part:


```c++
class Player : public Actor {
 public:
  Player& operator=(const Player& other) {
    // Assign base class part
    Actor::operator=(other); //<h>

    // Copy Player-specific members
    // ...

    return *this;
  }
};
```


## Virtual Copy Constructor Pattern


C++ doesn't support virtual copy constructors directly, but you can implement a similar pattern using a virtual clone method:


```c++
#include <memory>

class Weapon {
public:
  virtual ~Weapon() = default;
  virtual std::unique_ptr<Weapon> clone() const
    = 0;
};

class Sword : public Weapon {
public:
  std::unique_ptr<Weapon>
    clone() const override {
    return std::make_unique<Sword>(*this);
  }
};

// Usage
std::unique_ptr<Weapon> originalWeapon =
  std::make_unique<Sword>();
std::unique_ptr<Weapon> copiedWeapon =
  originalWeapon->clone();
```


This pattern allows you to create copies of derived objects through base class pointers.


## Slicing


Be cautious of object slicing when copying derived objects into base class objects:


```c++
#include <iostream>

class Weapon {
public:
  Weapon() = default;

  Weapon(const Weapon&) {
    std::cout << "Copying Weapon\n";
  }
};

class Sword : public Weapon {
public:
  Sword() = default;

  Sword(const Sword&) : Weapon() {
    std::cout << "Copying Sword\n";
  }
};

int main() {
  Sword sword;

  // Object slicing occurs here
  Weapon weapon = sword; //<w>
}
```


```plain text
//<o>
Copying Weapon
```


In this case, only the `Weapon` part of `sword` is copied, and any `Sword`-specific members are lost.


Understanding these interactions will help you implement robust copying behavior in your class hierarchies, avoiding common pitfalls and ensuring that objects are copied correctly at all levels of inheritance.

Copy Operations and Inheritance

In C++, the terms "explicit" and "implicit" in the context of copy operations refer to how these operations are defined and invoked. Understanding the difference is crucial for controlling object behavior and preventing unintended copies.


## Implicit Copy Operations


Implicit copy operations are those that the compiler generates automatically if you don't define them yourself. These include:

1. The default copy constructor
2. The default copy assignment operator

Here's an example of implicit copy operations:


```c++
#include <iostream>

class Player {
public:
  int health{100};
};

int main() {
  Player p1;
  Player p2 = p1; // Implicit copy constructor
  Player p3;
  p3 = p1; // Implicit copy assignment

  std::cout << "p2 health: " << p2.health <<
    "\n";
  std::cout << "p3 health: " << p3.health <<
    "\n";
}
```


```plain text
//<o>
p2 health: 100
p3 health: 100
```


In this case, the compiler generates a copy constructor and copy assignment operator that perform member-wise copying.


## Explicit Copy Operations


Explicit copy operations are those that you define yourself. You might do this to implement deep copying, manage resources, or prevent copying altogether. Here's an example:


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

class Weapon {
public:
  virtual ~Weapon() = default;
  virtual std::unique_ptr<Weapon> clone() const
  = 0;
};

class Player {
public:
  Player() : weapon(nullptr) {}

  // Explicit copy constructor
  Player(const Player& other) : health(
    other.health) {
    if (other.weapon) {
      weapon = other.weapon->clone();
    }
    std::cout <<
      "Explicit copy constructor called\n";
  }

  // Explicit copy assignment operator
  Player& operator=(const Player& other) {
    if (this != &other) {
      health = other.health;
      if (other.weapon) {
        weapon = other.weapon->clone();
      } else { weapon = nullptr; }
    }
    std::cout <<
      "Explicit copy assignment operator called\n";
    return *this;
  }

  int health{100};
  std::unique_ptr<Weapon> weapon;
};

int main() {
  Player p1;
  // Calls explicit copy constructor
  Player p2 = p1;

  Player p3;
  // Calls explicit copy assignment operator
  p3 = p1;
}
```


```plain text
//<o>
Explicit copy constructor called
Explicit copy assignment operator called
```


## Key Differences

1. Control: Explicit operations give you full control over the copying process.
2. Resource Management: Explicit operations allow proper handling of resources like dynamic memory.
3. Performance: Explicit operations can be optimized for your specific use case.
4. Preventing Copies: You can make copying explicit-only by declaring the copy operations as private or deleting them.

Understanding and properly implementing explicit copy operations when needed can lead to more robust and efficient code, especially when dealing with complex objects or resource management.

Explicit vs Implicit Copy Operations

The choice between deep copying and shallow copying can have significant performance implications in C++. Understanding these implications is crucial for writing efficient code, especially when dealing with large objects or frequently copied data structures.


## Shallow Copying


Shallow copying involves copying only the immediate data members of an object. For primitive types and pointers, this means copying the values directly. For pointers, the address is copied, not the pointed-to data.


Performance characteristics:

- Fast: Only copies the direct members of the object.
- Low memory usage: Doesn't duplicate underlying data for pointer members.
- Constant time complexity: $O(1)$ regardless of object size.

Example of shallow copying:


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

class ShallowPlayer {
public:
  ShallowPlayer(int* hp) : health(hp) {}
  int* health;
};

int main() {
  const int numCopies = 1'000'000;
  int hp = 100;

  auto start =
    std::chrono::high_resolution_clock::now();

  for (int i = 0; i < numCopies; ++i) {
    ShallowPlayer original(&hp);
    // Shallow copy
    ShallowPlayer copy = original;
  }

  auto end =
    std::chrono::high_resolution_clock::now();
  std::chrono::duration<double> diff = end -
    start;

  std::cout << "Time to perform " << numCopies
    << " shallow copies: " << diff.count() << "s";
}
```


```c++
//<o>
Time to perform 1000000 shallow copies: 0.0021545s
```


## Deep Copying


Deep copying involves creating a new copy of all data owned by the object, including dynamically allocated memory that the object might be pointing to.


Performance characteristics:

- Slower: Needs to allocate new memory and copy all underlying data.
- Higher memory usage: Duplicates all data, leading to increased memory consumption.
- Linear time complexity: $O(n)$ where n is the size of the underlying data.

Example of deep copying:


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

class DeepPlayer {
public:
  DeepPlayer(int hp) : health(
    std::make_unique<int>(hp)) {}

  DeepPlayer(const DeepPlayer& other)
    : health(
      std::make_unique<int>(*other.health)) {}

  std::unique_ptr<int> health;
};

int main() {
  const int numCopies = 1'000'000;

  auto start =
    std::chrono::high_resolution_clock::now();

  for (int i = 0; i < numCopies; ++i) {
    DeepPlayer original(100);
    DeepPlayer copy = original; // Deep copy
  }

  auto end =
    std::chrono::high_resolution_clock::now();
  std::chrono::duration<double> diff = end -
    start;

  std::cout << "Time to perform " << numCopies
    << " deep copies: " << diff.count() << "s";
}
```


```c++
//<o>
Time to perform 1000000 deep copies: 0.449998s
```


Running both these programs will show a significant performance difference, with shallow copying being much faster.


## Considerations

- Shallow copying is faster but can lead to issues with shared mutable state.
- Deep copying is safer for managing independent objects but comes with a performance cost.
- The choice depends on your specific use case. Sometimes, a mix of both approaches (like copy-on-write) can be optimal.
- For large objects or collections, the performance difference can be substantial and should be carefully considered in performance-critical code.

Remember, the right choice depends on your specific requirements for correctness, memory usage, and performance. Always profile your code to make informed decisions about copying strategies.

Performance: Deep vs Shallow Copying

Expanded copy assignment section to include example of updating the existing object

Fixed formatting error in Copy Assignment Operator section

Added note to explain difference between `Weapon =` and `*Weapon =`

Abstract art representing computer programming

Copy constructor

Copy assignment operator

`std::unique_ptr`

`std::shared_ptr`

C++ Core Guidelines: C.20: If you can avoid defining default operations, do

Copy constructors and copy assignment operators (C++)

{CPP}Master C++ object copying and resource management. Learn to implement custom copy constructors and assignment operators

{CPP}Mastering Object Copying and Resource Management

Preview: Sharing Ownership using `std::shared_ptr`

Copy Constructors and Operators

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers