C++ Operator Overloading, Friend Functions & Stream Operators Masterclass

#include <iostream>
#include <cmath>
#include <stdexcept>

class Vector2D {
    double x_, y_;
public:
    Vector2D(double x = 0, double y = 0) : x_{x}, y_{y} {}

    // Arithmetic operators (member)
    Vector2D operator+(const Vector2D& other) const {
        return {x_ + other.x_, y_ + other.y_};
    }
    Vector2D operator-(const Vector2D& other) const {
        return {x_ - other.x_, y_ - other.y_};
    }
    Vector2D operator*(double scalar) const {
        return {x_ * scalar, y_ * scalar};
    }

    // Compound assignment
    Vector2D& operator+=(const Vector2D& other) {
        x_ += other.x_; y_ += other.y_;
        return *this;
    }

    // Comparison
    bool operator==(const Vector2D& other) const {
        return x_ == other.x_ && y_ == other.y_;
    }
    bool operator!=(const Vector2D& other) const {
        return !(*this == other);
    }

    // Prefix increment
    Vector2D& operator++() {
        ++x_; ++y_;
        return *this;
    }

    // Postfix increment (dummy int parameter)
    Vector2D operator++(int) {
        Vector2D old = *this;
        ++(*this);
        return old;
    }

    // Index operator
    double& operator[](int idx) {
        if (idx == 0) return x_;
        if (idx == 1) return y_;
        throw std::out_of_range("Vector2D: index must be 0 or 1");
    }
    const double& operator[](int idx) const {
        if (idx == 0) return x_;
        if (idx == 1) return y_;
        throw std::out_of_range("Vector2D: index must be 0 or 1");
    }

    double magnitude() const { return std::sqrt(x_*x_ + y_*y_); }

    // Friend: Stream insertion (non-member accessing private data)
    friend std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
        return os << "(" << v.x_ << ", " << v.y_ << ")";
    }

    // Friend: scalar * vector (reversed operand order)
    friend Vector2D operator*(double scalar, const Vector2D& v) {
        return v * scalar;
    }
};

int main() {
    Vector2D a{3.0, 4.0}, b{1.0, 2.0};

    std::cout << "a        = " << a << "
";
    std::cout << "b        = " << b << "
";
    std::cout << "a + b    = " << (a + b) << "
";
    std::cout << "a - b    = " << (a - b) << "
";
    std::cout << "a * 2    = " << (a * 2.0) << "
";
    std::cout << "3 * a    = " << (3.0 * a) << "
";
    std::cout << "|a|      = " << a.magnitude() << "
";
    std::cout << "a == b   = " << std::boolalpha << (a == b) << "
";
    std::cout << "a[0]     = " << a[0] << "
";

    Vector2D c = a;
    std::cout << "c++ (post) = " << c++ << "  then c = " << c << "
";
    std::cout << "++c (pre)  = " << ++c << "
";
    return 0;
}