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

<Excerpt>


With built-in types, such as `int` and `string`, we've previously seen how we can set initial values when creating objects:


```c++
int Health { 100 };
string Name { "Roderick" };
```


In this lesson, we'll also learn how to give our user-defined types this same ability:


```c++
Monster Goblin { "Basher the Goblin" };
```


We unlock this by adding _**constructors**_ to our class.


</Excerpt>


## Constructors


A constructor in C++ is a special member function of a class that is executed whenever we create new objects of that class.  To define a constructor, we define a member function with two key characteristics:

- It has the same name as the class
- It has no return type (not even `void`)

For example, a constructor for a `Monster` class would look like this:


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

class Monster {
 public:
  Monster() {//<h>
    //<h>
  }//<h>
};
```


<Error>


### Non-Public Constructors


We should ensure our constructors are always `public`.


There are some scenarios where we would want a `protected` or `private` constructor, but those are for rare use cases that we'll cover in the advanced course.


When you encounter unexpected errors creating objects, ensure that your constructor in the `public` section so that it is accessible to the code that is trying to use it.


</Error>


The purpose of a constructor is to initialize the object's properties and can set up essential prerequisites for the object's functionality.


A constructor that takes no arguments is known as the _**default constructor**_.  Our previous example had no arguments, so it was the default constructor for our `Monster` type.


This type of constructor is used when we want to create an object but don't need to specify any initial values for its properties.


As we've seen, we've already been able to create our objects without any arguments using a statement like:


```c++
Monster Goblin;
```


This is because our classes are provided with a basic, default constructor as standard.  It doesn't appear in our code but, if the compiler sees a class without a default constructor, it will create a basic one for us behind the scenes.


However, we can replace this compiler-generated constructor with our own logic to implement whatever behaviour we need for our program.


Let's see a basic example of a default constructor in action:


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

class Monster {
 public:
  Monster() {//<h>
    cout << "Ready for Battle!";//<h>
  }//<h>

 private:
  string mName;
};

int main() {
  Monster Goblin;
}
```


```c++
//<o>
Ready for Battle!
```


<Aside>


### Class Variable Naming Conventions


In the previous example, we prefixed our class variables with the letter `m`, as in `mName`.  This is an abbreviation of "member".


Adopting a naming convention for class members, like prefixing with `m`, can be beneficial for several reasons.


This is especially useful when we're going to create constructors that accept parameters, as it prevents confusion between the parameters and the class members they are meant to initialize.


For example, to make our constructor clear for consumers, we'd want a parameter that initializes the object's name to be called `Name`.


But if the class member is also called `Name`, that can get quite confusing, especially in the constructor that's trying to set `Name` (in our class) equal to `Name` (from the parameter)


So, it's somewhat common to implement some standard naming conventions for our private internal members, such as prefixing them with `m`.


Other common naming conventions include using an underscore (`_`) as a prefix (e.g., `_name`) or a postfix (e.g., `Name_`). These conventions all serve the same purpose


</Aside>


## Constructor Parameters


Like other functions, constructors can be designed to take arguments, which we can use as needed within our constructor function body.


Typically, this is used to allow developers to pass values directly to the object's properties. For instance, a constructor that accepts a single argument can be used to set a specific property of a class.


Below, we've created a constructor that takes a `string` argument, granting the ability for our monster's name to be set at creation time:


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

class Monster {
public:
  Monster(string Name){//<h>
    mName = Name;//<h>
    cout << mName << " Ready for Battle!";//<h>
  }//<h>

private:
  string mName;
};

int main(){
  Monster Goblin{"Bonker"};//<h>
}
```


```c++
//<o>
Bonker Ready for Battle!
```


Similar to other types of functions, a constructor can have multiple parameters, separated by a comma.


When calling the constructor (by declaring an object of its type) we also comma-separate the arguments:


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

class Monster {
public:
  Monster(string Name, int Health){//<h>
    mName = Name;
    mHealth = Health;
    cout << mName << " Ready for Battle!"
      << "\nHealth: " << mHealth;
  }

private:
  string mName;
  int mHealth;
};

int main(){
  Monster Goblin{"Bonker", 150};//<h>
}
```


```c++
//<o>
Bonker Ready for Battle!
Health: 150
```


<Preview>


### Member Initializer Lists


In C++, constructors have a dedicated syntax for initializing member variables.  They are called _**member initializer lists**_, and they look like this:


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

class Monster {
public:
  Monster(string Name, int Health)
  : mName{Name}, mHealth{Health}//<h>
  {
    mName = Name;//<d>
    mHealth = Health;//<d>
    cout << mName << " Ready for Battle!"
      << "\nHealth: " << mHealth;
  }

private:
  string mName;
  int mHealth;
};

int main(){
  Monster Goblin{"Bonker", 150};//<h>
}
```


We'll stick with initializing members within the constructor body for now, and fully introduce member initializer lists and their benefits in a dedicated lesson in the next chapter.


</Preview>


## Multiple Constructors


Our classes can define multiple constructors, allowing our objects to be created with a variety of different argument lists.


Below, we allow consumers of our class to create our objects either by providing a `string` representing the monster's name, or both a `string` and an `int` representing their name and initial `Health` value:


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

class Monster {
 public:
  Monster(string Name) {//<h>
    mName = Name;//<h>
    mHealth = 150;//<h>
    cout << mName << " Ready for Battle!"//<h>
         << "\nHealth: " << mHealth;//<h>
  }//<h>

  Monster(string Name, int Health) {//<h>
    mName = Name;//<h>
    mHealth = Health;//<h>
    cout << mName << " Ready for Battle!"//<h>
         << "\nHealth: " << mHealth;//<h>
  }//<h>

 private:
  string mName;
  int mHealth;
};

int main() {
  Monster Bonker{"Bonker"};//<h>
  cout << '\n';
  Monster Basher{"Basher", 250};//<h>
}
```


```c++
//<o>
Bonker Ready for Battle!
Health: 150
Basher Ready for Battle!
Health: 250
```


Just like other functions, constructors can have optional parameters.  This allows multiple argument lists to be supported by a single constructor.


Our previous code can, and should, be simplified to this:


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

class Monster {
public:
  Monster(string Name, int Health = 150){//<h>
    mName = Name;
    mHealth = Health;
    cout << mName << " Ready for Battle!"
      << "\nHealth: " << mHealth;
  }

private:
  string mName;
  int mHealth;
};

int main(){
  Monster Bonker{"Bonker"};
  cout << '\n';
  Monster Basher{"Basher", 250};
}
```


```c++
//<o>
Bonker Ready for Battle!
Health: 150
Basher Ready for Battle!
Health: 250
```


## Ambiguous Constructor Calls


When defining multiple constructors, we need to ensure that they don't "overlap".  Specifically, any time we create an object, there must be only one constructor that supports the argument list that was provided.


Below, we have two constructors that both accept a single `int` parameter.


This is invalid because, if someone tries to instantiate our class with a single `int` argument, the compiler has no way of knowing what constructor is supposed to be used:


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

class Monster {
public:
  Monster(int Level){ mLevel = Level; }//<e>
  Monster(int Health){ mHealth = Health; }//<e>

private:
  int mLevel;
  int mHealth;
};

int main(){
  // Which Constructor?
  Monster Bonker{10};//<e>
}
```


When we fall foul of this requirement, we will typically get a compiler error at the point where our class is defined:


```c++
//<o>
error: 'Monster::Monster(int)': member function
already defined or declared
```


In some situations, our class definition may be valid, but we'll get an error if we try to create an object with an argument list that can be handled by multiple constructors:


```c++
//<o>
error: 'Monster::Monster': ambiguous call to
overloaded function
```


## Default Constructor


Previously, we've seen how we were able to create an object from our class, providing no arguments at all:


```c++
Monster Basher;
```


This is because, out of the box, our classes come with a default constructor.


However, once we define a custom constructor, the default is automatically deleted.


If we want to allow our objects to be created without arguments, we can simply reimplement the default constructor.  We do this by providing a constructor that takes no arguments:


```c++
class Monster {
 public:
  // A default constructor
  Monster() {//<h>
    // ...//<h>
  };//<h>

  Monster(string Name, int Health = 150) {
    mName = Name;
    mHealth = Health;
    cout << mName << " Ready for Battle!"
         << "\nHealth: " << mHealth;
  }

 private:
  string mName;
  int mHealth;
};
```


If we don't need to provide any implementation for this, we can use the `= default` syntax to restore the original default constructor:


```c++
class Monster {
 public:
  Monster() = default;//<h>

  Monster(string Name, int Health = 150) {
    mName = Name;
    mHealth = Health;
    cout << mName << " Ready for Battle!"
         << "\nHealth: " << mHealth;
  }

 private:
  string mName;
  int mHealth;
};
```


## Constructor prototypes


Similar to other functions, we can declare and define constructors in different locations.  The syntax is exactly the same as we covered in the previous lesson:


```c++
class Monster {
 public:
  // The prototype
  Monster(int Health);//<h>

 private:
  int mHealth{150};
};

// The definition
Monster::Monster(int Health){//<h>
  mHealth = Health;//<h>
}//<h>
```


## Destructor


A destructor in is another special member function of a class, complementary to the constructor.


It is called automatically when an object is deleted.


The syntax for a destructor is similar to the constructor but with a tilde (**`~`**) prefix. Here's a simple example:


```c++
class Monster {
 public:
  // Destructor
  ~Monster() {//<h>
    // ...//<h>
  }//<h>
};
```


When objects get destroyed, and the object lifecycle in general, will get more important as we get into more advanced topics.


For now, we can note that one scenario where objects will get destroyed is when the scope they were created in gets destroyed.


We can see an example of this below, where our `Goblin` is created within our function, and then automatically destroyed when our function ends:


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

class Monster {
public:
  // Constructor
  Monster(){
    cout << "Monster Created\n";
  }

  // Destructor
  ~Monster(){
    cout << "Monster Destroyed\n";
  }
};

void SomeFunction(){
  Monster Goblin;//<h>
}

int main(){
  cout << "Hello World\n";
  SomeFunction();
  cout << "Goodbye!";
}
```


```c++
//<o>
Hello World
Monster Created
Monster Destroyed
Goodbye!
```


<Quiz title="Constructors and Destructors">


<Question>


Imagine we have a class defined as follows:


```c++
class Robot {
public:
  Robot(string Model, int Year = 2024) {
    mModel = Model;
    mYear = Year;
  }

private:
  string mModel;
  int mYear;
};
```


What will be the result of creating a `Robot` object with the statement `Robot MyRobot("RX100");`?


<Answer>


The `MyRobot` object is created with `mModel` set to "RX100" and `mYear` left uninitialized.


<Feedback>


Not quite right, but close! In this case, `mYear` won't be left uninitialized. The constructor provides a default value of 2024 for `Year`.


</Feedback>
</Answer>
<Answer>


A compilation error occurs due to missing parameters.


<Feedback>


Good guess, but not quite! No compilation error will occur here. The constructor for **`Robot`** is designed to handle a situation where only one parameter is provided, thanks to the default value given to **`Year`**.


</Feedback>
</Answer>
<Answer isCorrect>


The `MyRobot` object is created with `mModel` set to "RX100" and `mYear` set to 2024.


<Feedback>


Excellent! You got it right. The `Robot` constructor provides a default value of 2024 for the `mYear` parameter. So, when the `MyRobot` object is created with only the model "RX100", `mYear` is automatically set to the default value of 2024.


</Feedback>
</Answer>
</Question>


<Question>


Given the following class definition:


```c++
class Creature {
public:
  Creature(string name) {
    mName = name;
  }

  Creature() {
    mName = "Unknown";
  }

private:
  string mName;
};
```


What happens if you create an object of `Creature` class without passing any arguments?


<Answer>


A compilation error occurs because of the missing argument.


<Feedback>


Incorrect. The code will not result in a compilation error in this case. The class `Creature` has a default constructor defined, which allows objects to be created without passing any arguments.


</Feedback>
</Answer>
<Answer isCorrect>


An object of `Creature` is created with the name "Unknown".


<Feedback>


Correct! Since the class `Creature` includes a default constructor that sets `mName` to "Unknown", creating an object without passing any arguments will invoke this constructor, resulting in an object with the name "Unknown".


</Feedback>
</Answer>
<Answer>


The object is created with an uninitialized name.


<Feedback>


Incorrect. The object will not have an uninitialized name. The default constructor explicitly initializes `mName` to "Unknown", so the object's name will be set accordingly.


</Feedback>
</Answer>
</Question>


<Question>
What happens when you define a custom constructor in a class without explicitly defining a default constructor?


<Answer>
The class automatically generates a default constructor.


<Feedback>
Incorrect. When a custom constructor is defined, the automatic generation of a default constructor is suppressed. If you need a default constructor, you must explicitly define it.


</Feedback>
</Answer>


<Answer isCorrect>
The class does not automatically generate a default constructor.


<Feedback>
Correct! When you define a custom constructor, the implicit default constructor is no longer provided. If you need a no-argument constructor, you have to define it explicitly.


</Feedback>


</Answer>
<Answer>
The compiler generates a compiler error.


<Feedback>
Incorrect. The compiler does not generate an error just because a default constructor is not defined. It only generates an error if you try to instantiate the class without providing the necessary arguments as per the defined constructor(s).


</Feedback>
</Answer>
</Question>


<Question>


Consider the following class definition:


```c++
class Weapon {
public:
  Weapon(int Durability){
    mDurability = Durability;
  }
  Weapon(int Weight){
    mWeight = Weight;
  }

private:
  int mDurability;
  int mWeight;
};
```


What will be the effect of creating a `Weapon` object with the statement `Weapon IronSword{500};`?


<Answer>


The `IronSword` object will be created with `mDurability` set to 500.


<Feedback>


Incorrect. The actual issue is constructor ambiguity, not incorrect assignment.


</Feedback>
</Answer>
<Answer>


The `IronSword` object will be created with `mWeight` set to 500.


<Feedback>


Incorrect. The problem here is not the assignment but the ambiguity of constructor calls.


</Feedback>
</Answer>


<Answer isCorrect>


A compilation error due to ambiguous constructor calls.


<Feedback>


Correct! This statement causes a compilation error because of ambiguity between the two constructors.


</Feedback>
</Answer>
</Question>


<Question>
What is a destructor?


<Answer>
A function that is called to allocate memory for an object.


<Feedback>
Not quite! A destructor is not used for allocating memory. Instead, it's the opposite: a destructor is a special member function that is invoked when an object is destroyed.


</Feedback>
</Answer>
<Answer isCorrect>
A special member function that is automatically called when an object goes out of scope or is deleted.


<Feedback>
Right! A destructor is indeed a special member function. It is automatically called when an object's lifetime ends, either because the object goes out of scope or it is explicitly deleted.


</Feedback>
</Answer>
<Answer>
A method that initializes an object's properties when it is created.


<Feedback>
Not exactly. You're thinking of a constructor, which initializes an object's properties when it is created. A destructor, on the other hand, does the opposite.


</Feedback>
</Answer>
</Question>


</Quiz>


## Summary


As we conclude this lesson, let's recap the key concepts we've covered:

- **Understanding Constructors and Destructors**: We've learned about constructors, special functions in a class that are called when objects are created. We've seen how these can be used to initialize objects with specific values and behaviors.
- **Default and Custom Constructors**: We explored how default constructors work and how we can create custom constructors to meet specific needs.
- **Naming Conventions for Class Variables**: The reason we might want to adopt class member naming conventions like prefixing member variables (e.g., `mName`).
- **Constructor Parameters**: We looked at how constructors can take parameters to initialize objects with specific values.
- **Handling Multiple Constructors**: We explored creating classes with multiple constructors, allowing for flexible object creation.
- **Avoiding Ambiguous Constructor Calls**: We learned the importance of ensuring constructors are not ambiguous to avoid compilation errors.
- **Implementing and Restoring Default Constructors**: We discussed how to implement custom default constructors and how to restore the original default constructor using `= default`.
- **Destructor Introduction**: We introduced destructors, which are called when objects are destroyed, and their role in resource management.

<Preview>


### Structs and Aggregate Initialization


In our next lesson, we will dive into the world of structs and aggregate initialization in C++. Here's what you can expect:

- **Understanding Structs**: We'll explore what structs are in C++, how they differ from classes, and why they are used.
- **Struct Syntax and Usage**: We'll cover the syntax of defining structs and how to use them effectively in your programs.
- **Comparing Structs and Classes**: An examination of the differences and similarities between structs and classes will help you understand when to use each.
- **Basics of Aggregate Initialization**: You'll learn about aggregate initialization, a method to initialize objects concisely and clearly.
- **Practical Examples**: As always, we'll provide examples to illustrate these concepts, ensuring you can apply them in your programming projects.

</Preview>

Added preview on member initializer lists

Added section on non-public constructors and expanded introduction to clarify naming and return type requirements

Default Constructors

Constructors (C++)

C++ Constructors: Types and Copy Constructors

Constructors and member initializer lists

Destructors in C++

Updated for C++23 | A detailed guide to class constructors and destructors.  Clear explanations and simple code examples

Constructors and Destructors

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming