111. Toggle Bitmask
The class Flags is already defined with a private 8-bit variable bits, a constructor, and a getter.
Your task is to overload the bitwise NOT (~) operator so that applying ~flags returns a new Flags object with all 8 bits inverted.
In main():
- Read an integer representing an 8-bit unsigned flag value
- Create a
Flagsobject using the lower 8 bits of the input - Apply the overloaded
~operator - Print both the original input value and the toggled value in the specified format
Input / Output Specification
Input:
A single integer N such that 0 ≤ N ≤ 255
Output:
Print the original input and the inverted value in the format:
Input=<input_value> Toggled Input=<toggled_value>
Example 1
Input:
0Output:
Input=0 Toggled Input=255
Example 2
Input:
255Output:
Input=255 Toggled Input=0
Example 3
Input:
170Output:
Input=170 Toggled Input=85
Constraints
- Input value represents an 8-bit unsigned flag
- Valid range: 0 to 255
- Only the lower 8 bits are considered
- Bit inversion must be limited to exactly 8 bits
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. |