Comparison and Coroutines

🚀 Modern C++ Features: Comparison & Coroutines

Imagine you’re a judge at a talent show. Before C++20, you had to write separate rules for “greater than,” “less than,” and “equal to.” Now, with ONE magic wand, you can decide ALL comparisons at once!

🎯 The Big Picture

Think of comparing things like sorting your toy box:

• Old Way: Check each toy one by one with many rules
• New Way: Wave a magic wand and instantly know the order!

That magic wand? It’s called the Spaceship Operator (<=>).

🌟 Three-Way Comparison

What Is It?

Imagine asking: “Is Apple bigger, smaller, or the same as Banana?”

Instead of asking THREE separate questions:

1. Is Apple > Banana?
2. Is Apple < Banana?
3. Is Apple == Banana?

You ask ONE question and get ONE answer that tells you everything!

The Magic Answer Types

// Three possible answers:
// negative = "less than"
// zero     = "equal"
// positive = "greater than"

Real Life Example:

• You have 5 candies, friend has 7
• Three-way comparison says: “You have LESS”
• One check tells the whole story!

Why This Matters

// OLD WAY - So much typing! 😫
bool operator<(const Toy& a, const Toy& b);
bool operator>(const Toy& a, const Toy& b);
bool operator==(const Toy& a, const Toy& b);
bool operator<=(const Toy& a, const Toy& b);
bool operator>=(const Toy& a, const Toy& b);
bool operator!=(const Toy& a, const Toy& b);

// NEW WAY - Just ONE line! 🎉
auto operator<=>(const Toy& a,
                 const Toy& b) = default;

🛸 The Spaceship Operator <=>

Why “Spaceship”?

Look at it sideways: <=> looks like a UFO! 🛸

    <=>
   /   \
  👽    👽

How It Works

#include <compare>

int a = 5;
int b = 10;

auto result = a <=> b;
// result is "less" because 5 < 10

The Three Categories

Think of comparing different things:

graph TD
    A["Comparison Types"] --> B["Strong Ordering"]
    A --> C["Weak Ordering"]
    A --> D["Partial Ordering"]
    B --> E["1 < 2 < 3<br/>Clear winner!"]
    C --> F["Case-insensitive<br/>A == a"]
    D --> G["NaN exists<br/>Some can't compare"]

1. Strong Ordering 💪

Like numbered jerseys - everyone has a unique spot!

// Integers have STRONG ordering
int x = 5, y = 10;
auto r = x <=> y;
// r is std::strong_ordering::less

2. Weak Ordering 🤝

Like sorting by height - ties are allowed!

// Case-insensitive strings
// "Hello" and "HELLO" are equivalent
// but not identical

3. Partial Ordering 🤷

Like comparing apples and oranges - sometimes you can’t!

// Floating point has PARTIAL ordering
// because NaN (Not a Number) can't
// be compared to anything!
double nan = std::nan("");
auto r = nan <=> 1.0;
// r is std::partial_ordering::unordered

Your Class Gets Superpowers!

struct Student {
    std::string name;
    int score;

    // ONE line gives you ALL comparisons!
    auto operator<=>(const Student&)
        const = default;
};

// Now you can do:
Student alice{"Alice", 95};
Student bob{"Bob", 87};

if (alice > bob)  // Works!
if (alice < bob)  // Works!
if (alice == bob) // Works!
// ALL SIX operators work automatically!

🔄 Coroutines: Functions That Can Pause!

The Story

Imagine reading a REALLY long book:

Normal Function (Regular Reading):

• Start at page 1
• MUST finish the whole book
• Can’t stop until THE END
• Others wait forever! 😴

Coroutine (Smart Reading):

• Read chapter 1… PAUSE ⏸️
• Go play outside! 🎮
• Come back, read chapter 2… PAUSE ⏸️
• Help mom cook! 🍳
• Continue where you left off!

The Three Magic Words

graph TD
    A["Coroutine Keywords"] --> B["co_await"]
    A --> C["co_yield"]
    A --> D["co_return"]
    B --> E["Wait for something"]
    C --> F["Give value & pause"]
    D --> G["Finish & give result"]

1. co_await - “Please Wait” ⏳

// Like waiting for your pizza delivery
Task<Pizza> orderDinner() {
    Pizza myPizza = co_await orderPizza();
    // Pauses here until pizza arrives!
    // Other code can run while waiting
    return myPizza;
}

Real Life:

• You order pizza online
• Instead of staring at the door…
• You play games while waiting!
• Door bell rings → get pizza → continue!

2. co_yield - “Here’s One!” 🎁

// Like a candy dispenser
Generator<int> countTo(int n) {
    for (int i = 1; i <= n; i++) {
        co_yield i;  // Give one number
        // Pause until asked for next!
    }
}

// Usage:
for (int num : countTo(5)) {
    std::cout << num << " ";
}
// Output: 1 2 3 4 5

Real Life:

• Vending machine gives ONE snack at a time
• You take it, eat it
• Come back for another!
• Machine remembers your count!

3. co_return - “I’m Done!” ✅

Task<std::string> greet(std::string name) {
    co_return "Hello, " + name + "!";
}

Why Coroutines Are Amazing

BEFORE (Blocking):
┌─────────────────────────────┐
│ Download File...            │
│ ████████████░░░░░░░░ 60%   │
│                             │
│ [Everything else FROZEN!] ❄️│
└─────────────────────────────┘

AFTER (Coroutines):
┌─────────────────────────────┐
│ Download: ███░░░ 30%        │
│ Upload:   █████░ 50%        │
│ Process:  ██░░░░ 20%        │
│ [All happening together!] 🎉│
└─────────────────────────────┘

A Complete Example

#include <coroutine>
#include <iostream>

// Simple generator
template<typename T>
struct Generator {
    struct promise_type {
        T value;

        Generator get_return_object() {
            return Generator{this};
        }
        std::suspend_always initial_suspend() {
            return {};
        }
        std::suspend_always final_suspend()
            noexcept { return {}; }
        std::suspend_always yield_value(T v) {
            value = v;
            return {};
        }
        void return_void() {}
        void unhandled_exception() {}
    };

    // Handle & iterator code...
    promise_type* promise;

    Generator(promise_type* p) : promise(p) {}
};

// Use it!
Generator<int> fibonacci(int count) {
    int a = 0, b = 1;
    for (int i = 0; i < count; i++) {
        co_yield a;
        int next = a + b;
        a = b;
        b = next;
    }
}

🎮 Quick Summary

💡 Remember This!

🛸 Spaceship Operator:
   One operator to rule them all!
   <=> gives you <, >, ==, !=, <=, >= for FREE!

🔄 Coroutines:
   Functions that can PAUSE and RESUME!
   Like a game you can save and continue later!

🌈 You Did It!

You just learned:

• ✅ Three-Way Comparison (one check tells all!)
• ✅ Spaceship Operator (the <=> superhero)
• ✅ Coroutines (pausable functions)

These features make C++ code:

• Shorter (less typing!)
• Smarter (better performance!)
• Simpler (easier to understand!)

Now go build something amazing! 🚀