Operator Overloading (Custom Semantics)

In C, operators like +, -, ==, or [] only work on built-in types (int, float). If you have a custom struct (e.g., Complex), you have to write clumsy functions like add_complex(a, b).

In C++, Operator Overloading allows you to define how standard operators behave for your custom classes. This lets you treat hardware objects or math structures just like native types.

Syntax & Usage

1. Basic Arithmetic (+, -)

Making complex data types (like Vectors or Fixed-Point numbers) intuitive to use.

class Vector {
public:
    int x, y;
    Vector(int x, int y) : x(x), y(y) {}

    // Overload '+' operator
    Vector operator+(const Vector& other) const {
        // Return a new object with the sum
        return Vector(this->x + other.x, this->y + other.y);
    }
};

// Usage
Vector v1(1, 2), v2(3, 4);
Vector v3 = v1 + v2; // v3 is (4, 6). Reads like math!

2. Array Subscript ([])

Allows a driver class to access internal memory or hardware buffers like a standard C array.

class EEPROM {
    uint32_t base_addr;
public:
    // Overload [] to read byte at offset
    uint8_t operator[](int offset) {
        return *(volatile uint8_t*)(base_addr + offset);
    }
};

EEPROM memory;
uint8_t val = memory[5]; // Reads hardware address (base + 5)

3. Comparison (==)

Simplify checking sensor states.

bool operator==(const SensorData& a, const SensorData& b) {
    return (a.id == b.id) && (a.val == b.val);
}

if (current_reading == last_reading) { /* ... */ }

How It Works (Syntactic Sugar)

Relevance in Embedded/Firmware

1. Fixed-Point Math

On microcontrollers without an FPU (Floating Point Unit), we often use integers to represent decimals (e.g., 100 = 1.00).

By wrapping this in a class and overloading +, -, *, /, you can write math code that looks like standard float math but compiles to efficient integer instructions.

2. Hardware Buffers

Overloading [] allows you to create "Safe Arrays" that check bounds before accessing memory.

uint8_t& operator[](int i) {
    assert(i < SIZE); // Safety check in Debug mode
    return buffer[i];
}

3. Bit Manipulation

You can overload | and & for enum class types (which don't support them by default) to create type-safe flag systems.

Common Pitfalls (Practical Tips)