05 C++ Notes

Loops

C++ Notes

size_t

size_t is a type. Any alias that names a type is itself a type.
It's a type alias for an unsigned integral type. Internally it resolves to unsigned int, unsigned long, or unsigned long long depending on the system.
Stores whole numbers only, no fractions, no negatives.
Used to represent sizes, counts, and indices in C++.
Guaranteed to be large enough to hold the size of any object in memory. That's the whole reason it exists.
It's the type sizeof() returns, and the type used internally by arrays and containers for indexing.

Not ideal when iteration involves negative numbers. Since size_t is unsigned, going below zero causes wrap-around to a huge number instead of a proper negative, which will break loop conditions silently, the loop just keeps running instead of stopping.

For Loop

Used to repeat a task a specific number of times.
Prefer size_t as the loop variable when iterating over sizes or container indices.
All three parts of the for loop header are optional, you can leave any of them blank.

C++

// standard for loop with size_t
for (size_t i{} ; i < 10 ; ++i) {
    // code runs 10 times
}

// to use the iterator outside the loop, declare it before
size_t i{};
for (i ; i < 10 ; ++i) {
    // code
}
// i is still accessible here

While Loop

Repeats code as long as a condition remains true.
The condition is checked before each iteration. If it's false from the start, the body never runs at all.
Can be used with an iterator just like a for loop, by managing the variable manually.

C++

while (condition) {
    // runs as long as condition is true
}

// with iterator
size_t i{};
while (i < COUNT) {
    ++i;
    // code
}

Do-While Loop

A variation of the while loop.
The body always executes at least once, even if the condition is false from the start.
The condition is checked after each iteration, not before.
Useful when you need to run the body first and then decide whether to repeat. A common case is input validation, where you need to ask at least once before you can check anything.

C++

do {
    // runs first, condition checked after
} while (condition);

Notice the semicolon after the closing while(condition). It's required and easy to forget, since regular while loops and for loops don't have one there.

Code Example: main.cpp

C++

#include <iostream>

int main() {
    std::cout << "sizeof(size_t): " << sizeof(size_t) << '\n'; // prints: 8 on 64-bit systems

    // for loop
    std::cout << "for loop:\n";
    for (size_t i{} ; i < 5 ; ++i) { // size_t: unsigned integer type alias
        std::cout << "i love cpp!\n"; // prints 5 times
    }

    // while loop with boolean flag
    std::cout << "\nwhile loop:\n";
    bool b{true};
    int i{5};
    while (b) {
        --i;
        std::cout << "i love cpp!\n"; // prints 5 times
        b = (i != 0); // when i hits 0, (0 != 0) is false, b becomes false, loop stops
    }

    // do-while: body runs once even though condition is false
    std::cout << "\ndo-while loop:\n";
    do {
        std::cout << "This executes even though condition is false\n\n"; // prints once
    } while (false);

    return 0;
}

Console Output

sizeof(size_t): 8 for loop: i love cpp! i love cpp! i love cpp! i love cpp! i love cpp! while loop: i love cpp! i love cpp! i love cpp! i love cpp! i love cpp! do-while loop: This executes even though condition is false

Which One to Reach For

Loop	Condition Checked	Best For
`for`	Before each iteration	You know how many times to repeat, or you're iterating by index
`while`	Before each iteration	You don't know the count ahead of time, repetition depends on a condition that changes elsewhere
`do-while`	After each iteration	The body must run at least once no matter what, like input validation prompts

Closing

Three loops, one real difference between them: whether the condition gets checked before the body runs or after. Next up, arrays.