110. Byte Buffer Indexing
Create a class ByteBuffer that stores an array of exactly 8 bytes using uint8_t and allows indexed access using an overloaded operator[].
The class must support:
Writing to a specific byte
buffer[i] = value;Reading a specific byte
x = buffer[i];
The overloaded operator must return a reference so that assignments work correctly.
Program Behavior:
- Read 8 integer values to initialize the buffer
- Read an index
idxand a valuev - Assign the new value using the overloaded operator
- Print all 8 bytes separated by spaces
Numeric Rules (Explicit):
- All stored values are
uint8_t - Input values will be in the range 0 to 255 inclusive
- No overflow, saturation, or wraparound handling is required
- Index will always be between 0 and 7
Example Input:
1 2 3 4 5 6 7 8
3 99
Example Output:
1 2 3 99 5 6 7 8
Constraints:
- Use
uint8_tinternally to store exactly 8 bytes operator[]must return a reference- Index range is guaranteed valid (
0–7) - Value range is guaranteed valid (
0–255)
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. |