114. Operator Overloading-II
Question.1
A developer attempts to overload specific operators within a class definition.
class Reg {
public:
void operator.(Reg& r); // dot
void operator::(int n); // scope resolution
void operator?:(int a, int b); // ternary
};What is the expected compilation result for these provided operators?
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)
| Expression | Compiler Translates To |
|---|---|
a + b | a.operator+(b) |
a == b | a.operator==(b) |
obj[i] | obj.operator[](i) |
ptr->x | ptr.operator->() (Smart Pointers) |
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)
| Pitfall | Details |
|---|---|
| ❌ Changing Meaning | Don't overload + to do subtraction. Operators should follow "Principle of Least Astonishment." If a + b deletes a file, no one will understand your code. |
| ❌ Logical Operators | Avoid overloading && and ` |
| ❌ Unary vs Binary | operator++() (Prefix) and operator++(int) (Postfix) have different signatures. Mixing them up causes infinite recursion or wrong behavior. |
| ✅ Zero Overhead | If implemented correctly (often inline), operator overloading has zero CPU cost compared to a manual function call. |