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>


Behind the scenes, every variable and object we create when programming is stored in binary.  That is a series of binary digits (bits), where each bit can have one of only two possible values.   The possible values are _**on**_ or _**off**_ - typically represented by `1` or `0`


Generally, we don't need to work on this level.  Our compilers and interpreters just abstract this away so we're acting on higher-level objects, like numbers and strings.


But, there are some use cases where working at the level of individual bits unlocks some new possibilities for us.  We'll introduce those in this lesson.


</Excerpt>


## Fixed Width Integers


Whenever we're selecting a data type that we'll be working with at the level of individual bits, it is common to choose a fixed-width unsigned integer.  In this lesson, we'll use `uint8_t`, which is available by including `<cstdint>`.


Fixed-width integers behave in the same way as `int`.  The key difference is that the language specification prescribes exactly how "wide" (that is, how many bits) are used in a fixed-width type.


The width of a basic `int` can be different on different platforms - it might be 16 bits, 32 bits, or 64 bits, so we generally don't use it in scenarios where we need fine-grained control at the level of individual bits.


`uint8_t` uses 8 bits on all platforms.  Numerically, this means it supports values in the range 0-255.


Below, we show the underlying binary representation of these numbers using <InlineLessonPromo url="intro-to-programming/string-interpolation" title="String Interpolation" description="A detailed guide to string formatting using C++20's `std::format()`, and C++23's `std::print()`">`std::format()`</InlineLessonPromo>, which allows us to output the binary form of an integer using the `:b` format specifier.


In the following example, we extend this to `:08b`, which represents three things:

- `b`: We want our output to be in binary
- `8`: We want our output to be 8 characters wide
- `0`: If outputting the value requires fewer than 8 characters, prepend as many `'0'` characters as needed to reach the target width

It looks like this:


```c++
#include <cstdint>
#include <format>
#include <iostream>

int main() {
  uint8_t i{0};
  while (true) {
    std::cout
      << std::format("\n{0:<3} = {0:08b}", i++);

    // Stop when i wraps around to 0
    if (i == 0) break;
  }
}
```


This program outputs the numbers from 0-255 as well as their bits, which we've truncated below:


```c++
//<o>
0   = 00000000
1   = 00000001
2   = 00000010
3   = 00000011
4   = 00000100
[...]
252 = 11111100
253 = 11111101
254 = 11111110
255 = 11111111
```


<Aside>


### `std::bitset` and `std::byte`


Recent iterations of the C++ specification include dedicated standard library types for scenarios where we want to work with binary data.  They have not yet been widely adopted, with simple integers remaining the most common approach.


We stick with integers in this lesson, and cover `std::bitset` and `std::byte` in detail in the next course.  All the concepts we use with integers also apply to these types, should we decide to switch.


</Aside>


## Bitwise Operators


The operators that work on individual bits are called _**bitwise operators**_.  We'll introduce the three most useful bitwise operators in this lesson, which closely relate to boolean logic.


We previously saw how the `||` and `&&` operators can be used to combine booleans in different ways.


These are called the "logical OR" and "logical AND" operators.  They have their bitwise counterparts, which combine sequences of bits:

- the bitwise OR operator - C++ and many other programming languages represent this by a single `|`
- the bitwise XOR (exclusive or) operator - typically represented by a caret: `^`
- the bitwise AND - typically represented by a single `&`

<Ad />


## The Bitwise `OR` Operator: `|`


The bitwise OR operator looks at the binary representation of its two operands and returns a new object of the same type.  Every bit in this new object is set to `1` if _**either**_ of the operands had a  `1` in that same position.


It's easier to demonstrate with a diagram:


<Img file="bitwiseOr.png" width="751" height="378" alt="Diagram illustrating the bitwise OR operator" blurHash="LBRCuhT0%f$g^-NdtRwbGFNxtRwI" multiply />


## The Bitwise `XOR` (exclusive or) Operator: `^`


XOR works very similarly to OR.  The only difference is that, when both operands had a `1` in the same position, the result of XOR will have a `0` in that corresponding position.


Another way to think of `XOR` is that it will have `1` in each position where the operands have _**different**_ values.


Here's an example:


<Img file="bitwiseXor.png" width="751" height="378" alt="Diagram illustrating the bitwise XOR operator" blurHash="LBRCuhT0%f$g^-NdtRwbGFNxtRwI" multiply />


## The Bitwise `AND` Operator: `&`


Similarly, the bitwise AND operator looks at the binary representation of its two operands and returns a new object of the same type.  Every bit in this new object is set to `1` if _**both**_ of the operands have a  `1` in that same position.


Here's an example:


<Img file="bitwiseAnd.png" width="751" height="378" alt="Diagram illustrating the bitwise AND operator" blurHash="L7S6GOXTx]$h^-NdtRwbGFNxtRwI" multiply />


## Use Case: Bit Flags


In the next course, we're going to be using the SDL library, which makes heavy use of bitwise operations in its API.  For example, it allows us to create a window and gives us a range of options on how that window should behave.


These are all _**flags**_ that we can enable or disable, covering things like:

- Is the window resizable?
- Is the window full-screen?
- Is the window movable?
- Is it always on top of other windows?

Without bitwise operators, there would be two main ways we would create this API.  We could just set our function up to receive a collection of booleans:


```c++
CreateWindow(false, true, true, false, true);//<w>
```


But this is not a particularly good design, as we can't easily read the behavior.  What flags are we setting to be `true` here?  Our IDE might help us out if we hover over the arguments, but that's extra effort, and code isn't always read in an IDE.


Alternatively, we could gather all of our booleans into a user-defined type, and then pass an object of that type to our function:


```c++
struct WindowSettings {
  bool Fullscreen{false};
  bool Resizable{false};
  bool Movable{false};
  bool AlwaysOnTop{false};
  bool Closable{false};
};

void CreateWindow(const WindowSettings& Flags) {
  // ...
}

int main(){
  WindowSettings Settings;
  Settings.Resizable = true;//<h>
  Settings.Movable = true;//<h>
  Settings.Closable = true;//<h>

  CreateWindow(Settings);
}
```


This makes it clearer what flags we're setting to `true`, but is quite verbose, and may have a performance overhead.


The best approach for this is often to use _**bit flags**_, and bitwise operators can help us implement them.


<Preview>


### Designated Initialization


C++20 introduced _**designated initialization**_, which allows us to make this struct-based approach a little more elegant.  Designated initialization allows us to specify by name the member variables we want to initialize, whilst leaving others at their default value.


The syntax looks like the following, where the values we're setting are prepended with `.`:


```c++
//<c title="WindowSettings Struct (Unchanged)">
//<l>struct WindowSettings {/*...*/};
struct WindowSettings {
  bool Fullscreen{false};
  bool Resizable{false};
  bool Movable{false};
  bool AlwaysOnTop{false};
  bool Closable{false};
};
//</c>

//<c title="WindowSettings Struct (Unchanged)">
//<l>void CreateWindow(const WindowSettings&) {/*...*/};
void CreateWindow(const WindowSettings& Flags) {
  // ...
}
//</c>

int main(){
  WindowSettings Settings;//<d>
  Settings.Resizable = true;//<d>
  Settings.Movable = true;//<d>
  Settings.Closable = true;//<d>
  CreateWindow(Settings);//<d>
  
  CreateWindow({//<h>
    .Resizable = true,//<h>
    .Movable = true,//<h>
    .Closable = true//<h>
  });//<h>
}
```


We cover <InlineLessonPromo slug="list initialization">designated initialization</InlineLessonPromo> in full detail in our advanced course, but even this approach is more verbose than the bit flag technique we'll cover next.


</Preview>


## Using Bitwise Operators for Bit Flags


With bitwise operators, we can create an API that looks like this:


```c++
CreateWindow(RESIZABLE | MOVABLE | CLOSABLE);
```


There are many ways to make this work.  The standard library comes with a `std::bitset` class to solve this problem.  Many others use an elaborate solution that involves enums.


Here, we'll do a basic, raw implementation using integers, so we can fully understand what is going on at a deep level.


<Ad />


The first step is to choose a numeric type for our flags.  We want our type to have enough bits to cover every possible flag.  A `uint8_t` has 8 bits, which can accommodate 8 flags.


We don't need to use every bit - if we just need 5 flags, we can still use an 8-bit type - we simply ignore 3 of the bits.


Next, we need to choose a distinct value for each of our flags.  Given we're using an integer, each value will be a number.


Each number we choose needs to have a single bit set to `1`, with all the others being `0`.  The pattern that achieves this starts at 1, and each subsequent number is double the previous.


That is, 1, 2, 4, 8, 16, 32, and so on.  The following program demonstrates this:


```c++
#include <cstdint>
#include <format>
#include <iostream>

int main() {
  for (uint8_t i:{1, 2, 4, 8, 16, 32, 64, 128}){
    std::cout
      << std::format("{0:<3} = {0:08b}", i)
      << '\n';
  }
}
```


```c++
//<o>
1   = 00000001
2   = 00000010
4   = 00000100
8   = 00001000
16  = 00010000
32  = 00100000
64  = 01000000
128 = 10000000
```


Next, we give each number in our sequence a descriptive name, which will be the flag it represents.


Typically we'd also include the number `0`, which has every bit set to `0`.  We use this to represent the absence of any flags  - that is, the equivalent of everything being `false`:


```c++
#include <cstdint>

const uint8_t NONE{0};           // 00000000
const uint8_t RESIZABLE{1};      // 00000001
const uint8_t MOVABLE{2};        // 00000010
const uint8_t CLOSABLE{4};       // 00000100
const uint8_t FULLSCREEN{8};     // 00001000
const uint8_t ALWAYS_ON_TOP{16}; // 00010000
```


This doubling pattern can continue if we need more flags.  If we need more than 8 flags, we'd need to switch to a type that has more than 8 bits.  For example, `uint16_t`, `uint32_t`, and `uint64_t` are also available.


We can now combine our flags in any way we want using the bitwise OR operator `|`.  We show some examples below, where every flag we include in our bitwise expression sets the corresponding bit in our `uint8_t` to `1`:


```c++
#include <cstdint>
#include <format>
#include <iostream>

//<c name="Flags">
//<l>const uint8_t NONE{0};
const uint8_t NONE{0};           // 00000000
const uint8_t RESIZABLE{1};      // 00000001
const uint8_t MOVABLE{2};        // 00000010
const uint8_t CLOSABLE{4};       // 00000100
const uint8_t FULLSCREEN{8};     // 00001000
const uint8_t ALWAYS_ON_TOP{16}; // 00010000
//</c>

void CreateWindow(uint8_t flags = NONE) {
  std::cout <<
    std::format("\nFlags: {0:08b}", flags);
}

int main() {
  // Set one bit to 1
  CreateWindow(CLOSABLE);//<h>

  // Set two bits to 1
  CreateWindow(FULLSCREEN | ALWAYS_ON_TOP);//<h>

  // Set three bits to 1
  CreateWindow(MOVABLE | CLOSABLE | RESIZABLE);//<h>
}
```


```c++
//<o>
Flags: 00000100
Flags: 00011000
Flags: 00000111
```


## Checking if a Bit Flag Was Set


In the function that receives our bit flags, we can determine which flags were set using the bitwise `&` operator.  For example, to check if the `CLOSABLE` flag was set, we can do this:


```c++
#include <cstdint>
#include <format>
#include <iostream>

//<c name="Flags">
//<l>const uint8_t NONE{0};
const uint8_t NONE{0};           // 00000000
const uint8_t RESIZABLE{1};      // 00000001
const uint8_t MOVABLE{2};        // 00000010
const uint8_t CLOSABLE{4};       // 00000100
const uint8_t FULLSCREEN{8};     // 00001000
const uint8_t ALWAYS_ON_TOP{16}; // 00010000
//</c>

void CreateWindow(uint8_t flags = NONE) {
  std::cout <<
    std::format("\nFlags: {0:08b}", flags);
  if (flags & CLOSABLE) {//<h>
    std::cout << "\nCLOSABLE was set\n";
  } else {
    std::cout << "\nCLOSABLE was NOT set\n";
  }
}

int main() {
  CreateWindow(CLOSABLE);
  CreateWindow(FULLSCREEN | ALWAYS_ON_TOP);
  CreateWindow(MOVABLE | CLOSABLE | RESIZABLE);
}
```


```c++
//<o>
Flags: 00000100
CLOSABLE was set

Flags: 00011000
CLOSABLE was NOT set

Flags: 00000111
CLOSABLE was set
```


It's likely to be unclear why this works, but it's important to understand what `flags & CLOSABLE` is doing.


The `CLOSABLE` variable sets a single bit to `1`.  Specifically, `CLOSABLE` is `00000100` - that is, the 3rd bit from the right is set to `1`


Therefore, given how the bitwise `&` works, there are only two possible outcomes when one of the operands is `00000100`: 

- If the other operand - `flags` in this case - also has a `1` in that position, the `&` operator will return `00000100`.  This is equivalent to the numeric value `4`.  `4`, and any other non-zero number, is `true` when treated as a boolean
- If the other operand - `flags` in this case - has a `0` in that position, the `&` operator will return `00000000`.  This is equivalent to the numeric value `0`.  `0` is `false` when treated as a boolean

The net effect of all of this is that the `flags & CLOSABLE` expression will be truthy _**only**_ if `flags` has its third bit from the right set to `1`.


An expression like `MOVABLE | CLOSABLE | RESIZABLE` generates a value with that bit set to `1`, whilst the value returned from an expression like `FULLSCREEN | ALWAYS_ON_TOP` will have the bit set to `0`


<Ad />


## Full Example


Below, we've hooked up all of our flags.  This lets us provide a `CreateWindow()` function that is quite elegant to use and, within that function, we can react as needed to whatever flags the caller has selected:


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

//<c name="Flags">
//<l>const uint8_t NONE{0};
const uint8_t NONE{0};           // 00000000
const uint8_t RESIZABLE{1};      // 00000001
const uint8_t MOVABLE{2};        // 00000010
const uint8_t CLOSABLE{4};       // 00000100
const uint8_t FULLSCREEN{8};     // 00001000
const uint8_t ALWAYS_ON_TOP{16}; // 00010000
//</c>

void CreateWindow(
  std::string Title, uint8_t flags = NONE
) {
  std::cout << Title << " has these flags:";
  if (flags == NONE) {
    std::cout << " NONE";
  }
  if (flags & RESIZABLE) {
    std::cout << " RESIZABLE";
  }
  if (flags & MOVABLE) {
    std::cout << " MOVABLE";
  }
  if (flags & CLOSABLE) {
    std::cout << " CLOSABLE";
  }
  if (flags & FULLSCREEN) {
    std::cout << " FULLSCREEN";
  }
  if (flags & ALWAYS_ON_TOP) {
    std::cout << " ALWAYS_ON_TOP";
  }
  std::cout << '\n';
}

int main() {
  CreateWindow("Window A");
  CreateWindow("Window B", FULLSCREEN);
  CreateWindow("Window C", RESIZABLE | MOVABLE);
}
```


```c++
//<o>
Window A has these flags: NONE
Window B has these flags: FULLSCREEN
Window C has these flags: RESIZABLE MOVABLE
```


## Summary


In this lesson, we explored bitwise operators, bit flags, and how to implement them in our own API designs


### Key Takeaways

- **Understanding Bitwise Operators**: Learned about the bitwise OR, AND, and XOR operators, and how they manipulate individual bits in binary representations of integers.
- **Fixed Width Integers**: Gained insights into using fixed-width integers like `uint8_t` for predictable, platform-independent bit manipulations.
- **Bit Flags in Practice**: Explored the practical application of bitwise operators for managing bit flags, a common technique in configuring settings or options compactly.

Added designated initializers preview and made minor improvements to most other sections

Bitwise operation

Arithmetic operators - cppreference.com

C++ Bitwise Operators

2.11. Bitwise Operators

Bitwise operators - Language syntax

{CPP}Step-by-step guide to mastering bitwise operators and bit flags / bit masks in C++

{CPP}C++ Basics: Mastering Bitwise Operators & Bit Flags

The Bitwise `XOR` (exclusive or) Operator: `^`

Bitwise Operators and Bit Flags

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming