Operator Overloading in C++ — How, Why, and When to Use It

#include <iostream>

// A simple 2D point class to illustrate the mechanics
struct Point2D {
    double x;
    double y;

    // Constructor for convenience
    Point2D(double xCoord, double yCoord) : x(xCoord), y(yCoord) {}

    // Overload '+' as a member function.
    // 'this' is the left operand, 'other' is the right operand.
    // Returns a brand-new Point2D — does NOT modify either original.
    Point2D operator+(const Point2D& other) const {
        return Point2D(x + other.x, y + other.y);
    }

    // Overload '==' to compare two points by value, not by memory address
    bool operator==(const Point2D& other) const {
        return (x == other.x) && (y == other.y);
    }
};

// Overload '<<' as a FREE (non-member) function.
// Why free? Because the LEFT operand is std::ostream, which we don't own.
// We return ostream& so chaining like (cout << a << b) works correctly.
std::ostream& operator<<(std::ostream& outputStream, const Point2D& point) {
    outputStream << "(" << point.x << ", " << point.y << ")";
    return outputStream; // MUST return the stream for chaining
}

int main() {
    Point2D startPosition(1.0, 2.0);
    Point2D displacement(3.5, -1.5);

    // This now reads exactly like arithmetic — clean and intuitive
    Point2D endPosition = startPosition + displacement;

    std::cout << "Start:    " << startPosition << std::endl;  // calls operator<<
    std::cout << "Move by:  " << displacement  << std::endl;
    std::cout << "End:      " << endPosition   << std::endl;

    // Test equality overload
    Point2D sameAsEnd(4.5, 0.5);
    if (endPosition == sameAsEnd) {
        std::cout << "Positions match!" << std::endl;
    }

    return 0;
}

#include <iostream>

class Currency {
private:
    long long centsValue; // Store as cents to avoid floating-point errors

public:
    explicit Currency(long long cents) : centsValue(cents) {}

    // --- MEMBER FUNCTION OPERATORS ---

    // '+=' modifies 'this' directly — perfect for a member function
    Currency& operator+=(const Currency& other) {
        centsValue += other.centsValue;
        return *this; // Return reference to self for chaining: a += b += c
    }

    // Unary negation — only one operand, always 'this'
    Currency operator-() const {
        return Currency(-centsValue);
    }

    // Prefix increment: ++amount
    Currency& operator++() {
        centsValue += 100; // add one dollar
        return *this;
    }

    // Postfix increment: amount++
    // The dummy int parameter is how C++ distinguishes pre vs post increment
    Currency operator++(int) {
        Currency snapshot = *this; // save current state
        centsValue += 100;         // then increment
        return snapshot;           // return the OLD value (standard postfix behavior)
    }

    // --- FRIEND FUNCTION OPERATORS ---

    // Binary '+' as a friend: both operands are Currency, but we want symmetry
    // and to avoid modifying either operand.
    friend Currency operator+(const Currency& lhs, const Currency& rhs) {
        return Currency(lhs.centsValue + rhs.centsValue);
    }

    // 'scalar * currency' AND 'currency * scalar' — friend handles both
    friend Currency operator*(const Currency& amount, int multiplier) {
        return Currency(amount.centsValue * multiplier);
    }
    friend Currency operator*(int multiplier, const Currency& amount) {
        return Currency(amount.centsValue * multiplier); // delegate to the above
    }

    // Stream output — left operand is ostream, so MUST be a non-member
    friend std::ostream& operator<<(std::ostream& stream, const Currency& amount) {
        long long dollars = amount.centsValue / 100;
        long long cents   = amount.centsValue % 100;
        stream << "$" << dollars << ".";
        // Pad cents with leading zero if needed (e.g., $5.05 not $5.5)
        if (cents < 10) stream << "0";
        stream << cents;
        return stream;
    }
};

int main() {
    Currency price(1099);      // $10.99
    Currency shipping(599);    // $5.99
    Currency discount(-200);   // -$2.00

    Currency total = price + shipping + discount; // uses friend operator+
    std::cout << "Total:       " << total << std::endl;

    total += Currency(100); // uses member operator+=
    std::cout << "After tax:   " << total << std::endl;

    Currency triplePrice = 3 * price; // scalar on LEFT — requires friend
    std::cout << "Triple price: " << triplePrice << std::endl;

    Currency oldTotal = total++; // postfix: oldTotal gets value BEFORE increment
    std::cout << "Old snapshot: " << oldTotal << std::endl;
    std::cout << "After post++: " << total    << std::endl;

    return 0;
}

#include <iostream>
#include <cstring>   // for strlen, strcpy
#include <algorithm> // for std::swap

// A string class that manages its own heap memory.
// This forces us to write a correct assignment operator.
class ManagedString {
private:
    char* buffer;  // heap-allocated character array
    size_t length;

public:
    // Constructor: allocates memory and copies the source string
    explicit ManagedString(const char* text = "") {
        length = strlen(text);
        buffer = new char[length + 1]; // +1 for null terminator
        strcpy(buffer, text);
        std::cout << "[Constructed: \"" << buffer << "\"]" << std::endl;
    }

    // Copy constructor: deep copy — allocate NEW memory
    ManagedString(const ManagedString& other) {
        length = other.length;
        buffer = new char[length + 1];
        strcpy(buffer, other.buffer);
        std::cout << "[Copy constructed: \"" << buffer << "\"]" << std::endl;
    }

    // Destructor: release heap memory
    ~ManagedString() {
        std::cout << "[Destroyed: \"" << buffer << "\"]" << std::endl;
        delete[] buffer;
    }

    // ASSIGNMENT OPERATOR using copy-and-swap idiom:
    // Step 1: 'other' is passed BY VALUE, which triggers the copy constructor.
    //         This is where the deep copy happens.
    // Step 2: We swap our internals with the copy's internals.
    // Step 3: The copy (now holding OUR old data) is destroyed at end of scope.
    // Self-assignment safe because a new copy is made BEFORE we touch 'this'.
    ManagedString& operator=(ManagedString other) { // intentional pass-by-value
        std::cout << "[Assignment operator called]" << std::endl;
        std::swap(buffer, other.buffer); // swap the pointers
        std::swap(length, other.length); // swap the lengths
        return *this;
        // 'other' (now holding our old data) is destroyed here — clean!
    }

    // Equality: same content, not same memory address
    bool operator==(const ManagedString& other) const {
        return strcmp(buffer, other.buffer) == 0;
    }

    bool operator!=(const ManagedString& other) const {
        return !(*this == other); // implement != in terms of ==, not independently
    }

    // Lexicographic less-than for sorting support
    bool operator<(const ManagedString& other) const {
        return strcmp(buffer, other.buffer) < 0;
    }

    friend std::ostream& operator<<(std::ostream& stream, const ManagedString& str) {
        stream << str.buffer;
        return stream;
    }
};

int main() {
    ManagedString greeting("hello");
    ManagedString copy("world");

    std::cout << "\n-- Assignment --" << std::endl;
    copy = greeting; // triggers copy-and-swap assignment

    std::cout << "\n-- Self-assignment (safe) --" << std::endl;
    greeting = greeting; // must not corrupt data

    std::cout << "\n-- Comparisons --" << std::endl;
    std::cout << "greeting == copy: " << (greeting == copy ? "true" : "false") << std::endl;
    ManagedString other("world");
    std::cout << "copy < other:     " << (copy < other ? "true" : "false") << std::endl;

    std::cout << "\n-- Cleanup --" << std::endl;
    return 0;
}

#include <iostream>
#include <cmath>    // for sqrt
#include <stdexcept> // for out_of_range

class Vec2 {
public:
    double x, y;

    Vec2(double xVal = 0.0, double yVal = 0.0) : x(xVal), y(yVal) {}

    // --- Arithmetic operators (return new Vec2, don't modify operands) ---

    Vec2 operator+(const Vec2& other) const { return Vec2(x + other.x, y + other.y); }
    Vec2 operator-(const Vec2& other) const { return Vec2(x - other.x, y - other.y); }
    Vec2 operator*(double scalar)     const { return Vec2(x * scalar,  y * scalar);  }
    Vec2 operator/(double scalar)     const { return Vec2(x / scalar,  y / scalar);  }
    Vec2 operator-()                  const { return Vec2(-x, -y); } // unary negate

    // --- Compound assignment operators (modify 'this', return reference) ---

    Vec2& operator+=(const Vec2& other)  { x += other.x; y += other.y; return *this; }
    Vec2& operator-=(const Vec2& other)  { x -= other.x; y -= other.y; return *this; }
    Vec2& operator*=(double scalar)      { x *= scalar;  y *= scalar;  return *this; }

    // --- Subscript operator for x/y access by index ---

    // Non-const version: allows writing  v[0] = 3.0
    double& operator[](int index) {
        if (index == 0) return x;
        if (index == 1) return y;
        throw std::out_of_range("Vec2 index must be 0 or 1");
    }
    // Const version: called when the Vec2 is const — read-only
    const double& operator[](int index) const {
        if (index == 0) return x;
        if (index == 1) return y;
        throw std::out_of_range("Vec2 index must be 0 or 1");
    }

    // --- Comparison operators ---

    bool operator==(const Vec2& other) const { return x == other.x && y == other.y; }
    bool operator!=(const Vec2& other) const { return !(*this == other); }

    // --- Utility methods (not operators, but complete the class) ---

    double magnitude() const { return std::sqrt(x * x + y * y); }
    Vec2   normalized() const { return *this / magnitude(); } // uses operator/

    // Dot product as a named function — NOT an operator.
    // Dot product has no natural operator symbol, so a method is cleaner.
    double dot(const Vec2& other) const { return x * other.x + y * other.y; }

    // --- Friend operators (left operand is NOT a Vec2) ---

    // Allows:  2.0 * velocity  (scalar on the left)
    friend Vec2 operator*(double scalar, const Vec2& vec) {
        return vec * scalar; // delegate to the member version above
    }

    friend std::ostream& operator<<(std::ostream& stream, const Vec2& vec) {
        stream << "[" << vec.x << ", " << vec.y << "]";
        return stream;
    }
};

int main() {
    // Simulating one frame of a simple 2D physics update
    Vec2 position(0.0, 10.0);     // starting position in meters
    Vec2 velocity(5.0, 0.0);      // meters per second
    Vec2 gravity(0.0, -9.8);      // gravitational acceleration
    double deltaTime = 0.016;     // ~60fps frame time in seconds

    std::cout << "=== Physics Simulation (1 frame) ==" << std::endl;
    std::cout << "Initial position: " << position << std::endl;
    std::cout << "Initial velocity: " << velocity << std::endl;

    // velocity += gravity * dt  — reads just like the physics equation
    velocity += gravity * deltaTime;

    // position += velocity * dt
    position += velocity * deltaTime;

    std::cout << "Updated velocity: " << velocity << std::endl;
    std::cout << "Updated position: " << position << std::endl;
    std::cout << "Speed (magnitude): " << velocity.magnitude() << " m/s" << std::endl;

    // Subscript access
    std::cout << "\nX-component of position: " << position[0] << std::endl;
    position[1] = 0.0; // floor clamp via subscript write
    std::cout << "After floor clamp: " << position << std::endl;

    // Scalar on the left side works too
    Vec2 scaledVelocity = 2.0 * velocity;
    std::cout << "Double speed: " << scaledVelocity << std::endl;

    return 0;
}