Prev Problem
Next Problem
Task
Discussion
Submissions
Solution
Report

89. Sensor Packet Handling

You must define a class Packet that represents a small telemetry packet sent from a sensor module.

Your class must:

  1. Store the following private members:
    • int id
    • int temperature
    • int humidity
  2. Provide:
    • A constructor that sets id and initializes temperature and humidity to 0
    • A method void update(int t, int h)
      • Updates temperature and humidity
    • A method void print()
      • Prints the packet contents in the format:
        • ID=<id> TEMP=<temperature> HUM=<humidity>
  3. In main():
    • Read id, t1, h1, t2, h2
    • Create a Packet object with the given id
    • Call update(t1, h1)
    • Call update(t2, h2)
    • Print the final packet using print()

Example Input:

7 20 40 25 45

Example Output:

ID=7 TEMP=25 HUM=45

Constraints:

  • All data members (id, temperature, humidity) must be private
  • Constructor must initialize temperature and humidity to 0
  • Print format must match exactly

 

 

 

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).