Basics of Classes

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)

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)