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>


So far, the code we have written has been able to create programs that execute a single stream of statements, and then exit.


In this lesson, we will learn about **loops**.  Loops will allow us to repeatedly execute a block of code, until some condition within our program changes.


</Excerpt>


## While Loops


The most basic form of loop is the `while` loop. It executes a block of code as long as a boolean expression remains `true`.


The basic structure of a `while` loop looks like this:


```c++
while (someBoolean) DoSomething();
```


Where we need to have multiple statements executed in our loop, we can wrap them with `{` and `}`, like in the following example:


```c++
while (someBoolean) {
  DoSomething();
  DoAnotherThing();
}
```


For example, to write the numbers from 1 to 10 to the console using a `while` loop, we could do this:


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

int main(){
  int Number{1};
  while (Number <= 10) {//<h>
    cout << Number << ", ";//<h>
    ++Number;//<h>
  }//<h>
}
```


```c++
//<o>
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
```


The syntax of a `while` loop is very similar to the `if` statements we have seen in the past.  We have the keyword `while`, a boolean expression inside `(` and `)`, and a statement to execute.


The main difference between an `if` and a `while` is that:

- an `if` statement will execute _**once**_ if the provided expression is true
- a `while` statement will execute _**continuously**_, as long as the provided expression remains true.

<Definition>


### Iteration


The phrase _**iteration**_ is commonly used to describe code that involves loops.  For example,

- _"the variable is increased on every iteration"_
- _"we iteratively call the_ _`Log()`_ _function"_
- _"we iterate over every object in the collection"_

</Definition>


If the condition provided to a `while` loop is `false` at the point the `while` loop attempts to start, the code inside the block is not executed - not even once.


The following code will not log out anything:


```c++
while (false) {
  cout << "Can't see me!";
}
```


<Quiz title="Using `while` Loops">


<Question>


What will be the value of `i` after running this code?


```c++
int i { 0 };
while (i <= 5) {
  ++i;
}
```


<Answer>


The integer value `5`


<Feedback>


Remember, a `while` loop continues as long as the condition is true. Consider how the incrementing of `i` inside the loop impacts the final value when the loop exits.


</Feedback>


</Answer>


<Answer isCorrect>


The integer value `6`


<Feedback>


Correct! The loop increments `i` until it is no longer less than or equal to 5, hence `i` becomes 6.


</Feedback>


</Answer>


<Answer>


This code will never stop running.


<Feedback>


Analyze the condition of the loop and how the value of `i` changes with each iteration. Does it ever meet a condition to stop?


</Feedback>


</Answer>


<Answer>


This code will not compile.


<Feedback>


Review the syntax of the `while` loop and the code within the loop. Is there anything syntactically incorrect?


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


<Preview>


### Application Loops


In most software we use, we've probably noted that the program runs continuously until we explicitly tell it to stop by, for example, pressing a button in the UI.


This is possible because the program is effectively just one big loop - usually a `while` loop.


The outermost loop of a program that keeps everything running is sometimes referred to as the _**application loop**_ or, if our application is specifically a game, the _**game loop**_. On every iteration, this loop orchestrates tasks like:

- Handling any user input that has happened since the previous iteration - including whether the user wants to quit
- Updating the state of any variables and objects as needed
- Rendering an update to the screen

```c++
int main(){
  bool shouldQuit{false};
  while (!shouldQuit) {
    shouldQuit = getUserInput();
    UpdateState();
    RenderToScreen();
  }
}
```


We'll be building our own, real application loops later in the course


</Preview>


## Do While Loops


A `do while` loop is very similar to a `while` loop, with two key differences. The first is that the syntax is slightly different - the condition comes at the end of the block:


```c++
do {
  // Body here
} while (shouldLoop);
```


To log out the numbers from 1-10 using a `do while` loop, we could do this:


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

int main(){
  int Number{1};
  do {//<h>
    cout << Number << ", ";//<h>
    ++Number;//<h>
  } while (Number <= 10);//<h>
}
```


The second difference between a `while` and a `do while` is that the code inside the block of a `do while` loop will always be executed at least once, even if the boolean is initially `false`.


The following code will log out `Hello World!` one time.


```c++
do {
  cout << "Hello World!" << endl;
} while (false);
```


<Quiz title="Using `do while` Loops">


<Question>


What will be the value of `i` after running this code?


```c++
int i = 0;
do {
  ++i;
} while (i < 0);
```


<Answer>


The integer value `0`


<Feedback>


The `do while` loop runs at least once before checking the condition. How does this affect the final value of `i`?


</Feedback>


</Answer>


<Answer isCorrect>


The integer value `1`


<Feedback>


Correct! Since a `do while` loop always executes at least once before checking the condition, `i` is incremented to 1.


</Feedback>


</Answer>


<Answer>


This code will never stop running.


<Feedback>


Consider the placement of the condition in a `do while` loop and how it influences the number of iterations.


</Feedback>


</Answer>


<Answer>


This code will not compile.


<Feedback>


Review the structure of the `do while` loop. Is the loop constructed correctly according to the syntax rules?


</Feedback>


</Answer>


</Question>


</Quiz>


## For Loops


The third type of loop, the `for` loop, is slightly more complicated.  The basic structure is:


```c++
for (initialize; condition; update) {
  // Code here
}
```


We have three components inside the `(` and `)` of the `for` loop. These are:

- **Initialize** - this statement is executed a single time, before our loop starts
- **Condition** - this is the boolean expression that indicates if our loop should continue
- **Update** - this code is executed at the end of each loop iteration

These three components are separated by a semicolon `;`


Let's see an example of how we can use this to log out the numbers from 1 to 10:


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

int main(){
  for (int Number{1}; Number <= 10; ++Number) {//<h>
    cout << Number << ", ";//<h>
  }//<h>
}
```


```c++
//<o>
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
```


<Quiz title="Using `for` Loops">


<Question>


What will be the value of `i` after running this code?


```c++
int Number { 0 };
for (int i { 0 }; i < 10; ++i) {
  Number++;
};
```


<Answer>


The integer value `9`


<Feedback>


Think about how many times the loop runs and how it affects the value of `Number`. Is the loop incrementing `Number` each time?


</Feedback>


</Answer>


<Answer isCorrect>


The integer value `10`


<Feedback>


You got it! The loop will run 10 times, from `i = 0` to `i = 9`. The 10th iteration will increment both `i` and `Number` a final time, leaving both variables with a value of `10`.


</Feedback>


</Answer>


<Answer>


This code will never stop running.


<Feedback>


Analyze the loop's condition and the update statement. Does the loop have a clear endpoint?


</Feedback>


</Answer>


<Answer>


This code will not compile.


<Feedback>


Look over the `for` loop syntax and the code inside it. Are there any syntax errors that would prevent compilation?


</Feedback>


</Answer>


</Question>


</Quiz>


With `for` loops, all three components inside the `(` and `)` are optional.  We can omit the ones we don't need.


However, we still do need to keep the semicolons, to disambiguate which components we are using.


For example, to omit the 1st and 3rd components, we could do this:


```c++
int Number { 1 };
for ( ; Number < 10 ; ) {//<h>
  cout << Number << ", ";
  ++Number;
}
```


The above is rather messy code.  We should just use a `while` loop in that scenario, but it is possible to use a `for` loop.  We can even remove the conditional check:


```c++
int Number { 1 };
for ( ; ; ) {//<h>
  cout << Number << ", ";
  ++Number;
}
```


This code will compile, but you may see a problem with it.  We're not specifying when the loop should stop, so the loop will never stop.


<Ad />


## Infinite Loops


Inevitably, we will make a mistake when writing a loop that causes the loop to never end. For example:


```c++
int Number { 1 };
while (Number <= 10) {
  cout << Number << ", ";
  // Oops!  we forgot to increment Number
}
```


Because the body of our loop does not affect the boolean expression that controls when our loop ends, this loop will not end under normal circumstances.


`Number` will always be `<= 10`. This is a fairly common scenario, called an **infinite loop**.


When we introduce an infinite loop, the remedy is usually just to force our program to close. For programs running in our terminal that are stuck in an infinite loop, we should still be able to close them from the title bar.


If that doesn't work, or we're creating a program that doesn't have the title bar, we can generally force our programs to close from our operating system - eg, _ctrl_ + _alt_ + _delete_ in Windows, or _Force Quit_ on macOS.


## Loop Scopes


The blocks created by our loop statements behave like any blocks we've seen, such as those associated with functions and `if` statements.


They have their scope, inside which we can create variables and call functions.


<LessonPromo url="intro-to-programming/scope" title="Scope" description="Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist." />


The same scope rules apply - for example, code within the blocks created by our loop can access variables in parent scopes, as we've seen:


```c++
int Number { 1 };
while (Number <= 10) {
  // Accessing a parent scope
  cout << Number << ", ";//<h>
}
```


However, if we create a variable within our loop, code outside of the loop will _**not**_ be able to access it, for the exact same reasons we covered earlier in our lesson on scopes:


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

int main() {
  while (true) {
    int Number{1};
    //
  }
  cout << Number;//<e>
}
```


```c++
//<o>
error: 'Number': undeclared identifier
```


Finally, it's worth acknowledging that every iteration of our loop creates a new block scope.


Every iteration of our previous loop creates a new variable called `Hello`, in a new block created just for that iteration of the loop.


Any variables that were declared within an iteration's block are no longer accessible once that iteration completes.


## Nesting Conditionals within Loops


Within the block of a loop, we can apply most of the techniques we've been doing so far.  For example, we can create variables, call functions, and use conditional logic.


For example, to log out the numbers from 1-10, but to treat one number differently, we could nest an `if` statement inside our loop:


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

int main(){
  int Number{1};
  while (Number <= 10) {
    if (Number == 5) {
      cout << "Five" << ", ";
    } else { cout << Number << ", "; }
    ++Number;
  }
}
```


```c++
//<o>
1, 2, 3, 4, Five, 6, 7, 8, 9, 10,
```


## Nesting Loops within Loops


We can also nest loops within loops. For example, the following logs out a 3x3 grid using nested loops:


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

int main(){
  for (int Row{1}; Row <= 3; ++Row) {
    for (int Col{1}; Col <= 3; ++Col) {
      cout << "Row " << Row << ", "
        << "Col " << Col << " | ";
    }
    cout << '\n';
  }
}
```


```c++
//<o>
Row 1, Col 1 | Row 1, Col 2 | Row 1, Col 3 |
Row 2, Col 1 | Row 2, Col 2 | Row 2, Col 3 |
Row 3, Col 1 | Row 3, Col 2 | Row 3, Col 3 |
```


In the above example, we have an outer loop that logs out 3 rows, with a new line - `\n` - after each one.


Within each iteration of this outer loop, we have an inner loop, which also performs 3 iterations.  Each iteration logs out a cell of that row.


The net effect is our outer loop iterates 3 times, each causing 3 iterations of the inner loop.


So, the code within the inner loop is invoked 9 times in total.


In the next lesson, covering the modulus operator, we will see a slightly simpler way of implementing this behavior.


<Ad />


## The `continue` Statement


We can use the `continue` keyword within the body of a loop to give us more control over its execution. When we call `continue`, the loop will skip over the remaining code for this iteration, and continue onwards to the next.


If the condition that controls the loop is no longer `true`, the loop will instead end.


The `continue` statement is most typically used in a conditional block within our loop.


For example, to log the numbers from 1-10, whilst skipping over 5, we could write this code:


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

int main(){
  int Number{0};
  while (Number < 10) {
    ++Number;
    if (Number == 5) continue;
    cout << Number << ", ";
  }
}
```


```c++
//<o>
1, 2, 3, 4, 6, 7, 8, 9, 10,
```


<Quiz title="Using the `continue` Statement">


<Question>


What will be the value of `Number` after running this code?


```c++
int Number { 0 };
for (int i = 0; i < 10; ++i) {
  if (i == 5) continue;
  Number++;
};
```


<Answer isCorrect>


The integer value `9`


<Feedback>


Correct! The loop will run 10 times, but on one of those iterations, we're calling `continue` before we increment `Number`. Therefore, `Number` will only be incremented 9 times.


</Feedback>


</Answer>


<Answer>


The integer value `10`


<Feedback>


Consider the role of the `continue` statement and how it interacts with the incrementation of `Number`.


</Feedback>


</Answer>


<Answer>


This code will never stop running.


<Feedback>


Examine the conditions under which the loop continues and the role of the `continue` statement in it. Does the loop have a valid termination condition?


</Feedback>


</Answer>


<Answer>


This code will not compile.


<Feedback>


Review the syntax used in the loop and the `continue` statement. Are there any syntactical errors?


</Feedback>


</Answer>


</Question>


</Quiz>


## The `break` Statement


The `break` keyword can be called within the body of a loop, to exit the loop entirely, and to stop iterating. Similar to how `continue` was used, `break` is generally most useful within a conditional in our loop.


For example, to limit a `while` loop to 100 iterations, regardless of whether the condition is `true`, we could do this:


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

int main(){
  int RemainingIterations{100};

  while (true) {
    --RemainingIterations;
    if (RemainingIterations <= 0) break;//<h>
  }
}
```


The `break` statement gives us an alternative way to control when our loops end.  In some situations, using this approach can be an easier way to control program flow than using a boolean expression.  We're free to use whatever approach makes most sense for our specific problem.


<Quiz title="Using the `break` Statement">


<Question>


What will be the value of `i` after running this code?


```c++
int i { 0 };
while (i >= 0) {
  if (i == 5) break;
  ++i;
};
```


<Answer isCorrect>


The integer value `5`


<Feedback>


Correct! The `break` statement is executed when `i` reaches 5, thus terminating the loop immediately.


</Feedback>


</Answer>


<Answer>


The integer value `6`


<Feedback>


Think about when the `break` statement is executed within the loop. Does `i` get a chance to increment to 6?


</Feedback>


</Answer>


<Answer>


This code will never stop running.


<Feedback>


Consider how the `break` statement influences the continuation of the loop. Is there a scenario where the loop doesn't end?


</Feedback>


</Answer>


<Answer>


This code will not compile.


<Feedback>


Check the construction of the loop and the use of the `break` statement. Are there any syntax issues?


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Returning from Loops


Within a loop, we can also use a `return` statement to end the execution of the function where our loop is running.


This act also implicitly ends our loop, as if we called `break` on it.


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

void Log(){
  for (int i{1}; i < 10; ++i) {
    cout << i << ", ";
    if (i == 5) return;//<h>
  }
}

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


```c++
//<o>
1, 2, 3, 4, 5,
```


Note, however, that there is a subtle difference between `return` and `break`

- `break` will end the loop
- `return` will end both the loop and function

This has implications if our function has further code after the end of the loop.  In the following example, our program will never say "Goodbye" - that is effectively unreachable code:


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

void Log(){
  for (int i{1}; i < 10; ++i) {
    cout << i << ", ";
    if (i == 5) return;//<h>
  }
  cout << "Goodbye";//<w>
}

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


```c++
//<o>
1, 2, 3, 4, 5,
```


But replacing the `return` statement with `break` will have the desired effect:


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

void Log(){
  for (int i{1}; i < 10; ++i) {
    cout << i << ", ";
    if (i == 5) break; //<h>
  }
  cout << "Goodbye";
}

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


```c++
//<o>
1, 2, 3, 4, 5, Goodbye
```


## Summary


In this lesson, the key points we should remember are:

- **Loops**: Loops allow for repeating a block of code multiple times based on certain conditions.
- **While Loops**: The `while` loop executes as long as its condition remains true
- **Do While Loops**: The `do while` loop executes at least once, regardless of the initial condition.
- **For Loops**: The `for` loop allows us to set initialization, condition, and update components.
- **Infinite Loops**: Infinite loops do not end under normal circumstances.  They're usually bugs, often caused by the loop body not affecting the boolean expression that determines when the loop should terminate
- **Loop Scopes**: Each iteration of a loop creates a new block scope.  Variables defined within a loop are not accessible outside of it.
- **Nesting Conditionals and Loops**: We can use conditional statements and other loops within a loop, enhancing the flexibility of each.
- **Control Statements in Loops**: We can use `continue`, `break`, and `return` statements within loop bodies to further control the flow of our program

<Preview>


### The Modulus Operator


The next lesson will introduce the modulus operator `%`, a tool often used in conjunction with loops.  We'll cover:

- **Integer Division**: Understanding the quotient and remainder of integer division
- **Practical Applications**: We will explore how the modulus operator can be used to perform operations like determining even or odd numbers, creating patterns, and more.
- **Integration with Loops**: The lesson will demonstrate how the modulus operator can be used within different types of loops.

</Preview>

C++ for Loop (With Examples)

C++ Loops

For loops - Learn C++ - Free Interactive C++ Tutorial

C++ while and do...while Loop (With Examples)

C++ for loop

8.10 - For statements - Learn C++

{CPP}Explore C++ loops with in-depth explanations of while, for, and do while loops.

Loops

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming