Prev Problem
Next Problem
Task
Discussion
Submissions
Solution
Report

87. LED Toggle Class

Create a class LED that represents a simple LED connected to a microcontroller GPIO pin.

Your class must:

  1. Store two private data members:
    • int pin → GPIO pin number (non-negative integer)
    • int state → LED state (0 = OFF, 1 = ON)
  2. Provide a constructor that:
    • Accepts the GPIO pin number
    • Initializes the LED state to OFF
  3. Provide the following public member functions:
    • void on() → sets the LED state to 1
    • void off() → sets the LED state to 0
    • void toggle() → flips the LED state (0 ↔ 1)
    • int status() → returns the current LED state (0 or 1)
  4. In main():
    • Read three integers from input:
      • pin → GPIO pin number
      • initialState → initial LED state (0 or 1 only)
      • toggleCount → number of times to toggle the LED (≥ 0)
    • Create a LED object using the given pin
    • Set the initial LED state based on initialState
    • Call toggle() exactly toggleCount times
    • Print the final LED state (0 or 1) using status()

Example Input:

5
1
3

Example Output:

0

Explanation:
Start ON → toggle 3 times → OFF

Constraints:

  • initialState is guaranteed to be either 0 or 1
  • toggleCount is guaranteed to be a non-negative integer
  • state and pin must be private
  • Only class methods may modify state
  • Output must be exactly one integer: 0 or 1

 

 

 

Need Help? Refer to the Quick Guide below

In C, we use struct to bundle data together. However, the data is completely open—anyone can modify any field at any time, often leading to bugs (e.g., changing a buffer index without checking bounds).

In C++, a Class is an extension of a struct that adds Encapsulation. It bundles data (variables) and logic (functions) together, and uses Access Specifiers (private, public) to control who can see or touch that data.

Note: In C++, the only technical difference between a struct and a class is that members are public by default in a struct, and private by default in a class.

Syntax & Usage

1. Basic Declaration

Grouping hardware register definitions and the functions that use them into a single unit.

class Motor {
private:
    // Only functions inside this class can access these variables.
    // This protects the hardware state from accidental corruption.
    int pwm_pin;
    int speed; 

public:
    // The "Public API" - The rest of the code uses these functions.
    
    // Constructor (Initializes the object)
    Motor(int pin) {
        pwm_pin = pin;
        speed = 0;
        // Hardware init logic...
    }

    void setSpeed(int s) {
        if (s > 100) s = 100; // Safety check (Invariant)
        if (s < 0) s = 0;
        speed = s;
        // Apply to hardware...
    }
};

2. Usage

int main() {
    Motor m1(9);      // Create object 'm1' on pin 9

    m1.setSpeed(50);  // ✅ OK: Accessing public function
    
    // m1.speed = 200; // ❌ Error: 'speed' is private
}

Struct vs. Class (Memory Layout)

FeatureC structC++ class
Data AccessPublic (Open to everyone).Controlled (private/public).
LogicFunctions are separate.Functions are members.
MemorySum of members (+ padding).Identical (Sum of members + padding).
OverheadNone.Zero (unless Virtual Functions are used).

Relevance in Embedded/Firmware

1. Hardware Driver Encapsulation

This is the most important use case. You can hide the ugly, complex hardware register pointers inside the private section.

The Application Developer (User) just sees uart.init() and uart.send(). They don't need to know (and shouldn't touch) the UART->CR1 register directly.

2. Maintaining Invariants

An Invariant is a rule that must always be true (e.g., "Buffer index must never exceed 64").

If you use a C struct, a user can write buf.index = 100; and crash the system.

With a C++ class, you make index private. The user must call buf.advance(), which internally checks if (index < 64). This guarantees the system acts predictably.

3. Multiple Instances

In C, writing a driver that supports 3 UARTs often requires passing a context pointer (UART_Handle_t*) to every function.

In C++, you simply create 3 objects: UART u1, u2, u3;. The compiler handles the context (this pointer) automatically, making code cleaner.

Common Pitfalls (Practical Tips)

PitfallDetails
❌ The "Size" MythBeginners fear classes use more RAM. A class with two ints takes exactly 8 bytes, just like a struct with two ints. There is no hidden metadata unless you use virtual functions.
❌ Getters/Setters BloatDon't blindly make everything private and add getX()/setX() for every variable. That defeats the purpose. Only expose what the user needs to do their job.
❌ Public DataAvoid public member variables (e.g., public: int data;). If the user writes obj.data = 0;, your class doesn't know it changed, so it can't update dependent hardware states.
✅ Structs for DataUse struct for simple data containers (like a data packet or coordinate) where all fields are effectively public. Use class for objects that do things (Drivers, Managers).