164. PWM Register Access Control

C++ provides three keywords to control who can see and modify class members.

The "Safe Hardware" Example

Imagine a Motor Driver where the duty cycle must never exceed 90% (safety limit) and never be negative.

class MotorDriver {
private: 
    // DATA HIDING:
    // If this were public, a user could write 'duty_cycle = 200;' and burn the motor.
    float duty_cycle;
    uint32_t* pwm_reg; 

    // INTERNAL HELPER:
    // A complex hardware sequence user doesn't need to see.
    void trigger_update() { 
        *pwm_reg = (uint32_t)(duty_cycle * 1000); 
    }

public:
    // CONSTRUCTOR: Initializes state safely.
    MotorDriver() : duty_cycle(0.0f) { /* ... */ }

    // PUBLIC INTERFACE (Setter):
    // Contains Validation Logic (The "Invariant").
    void setSpeed(float speed) {
        if (speed > 90.0f) speed = 90.0f; // Clamp to safe max
        if (speed < 0.0f)  speed = 0.0f;  // Clamp to safe min
        
        duty_cycle = speed; // Update internal state
        trigger_update();   // Update hardware
    }

    // PUBLIC INTERFACE (Getter):
    // Read-only access.
    float getSpeed() const {
        return duty_cycle;
    }
};

• The friend Keyword (Controlled Breach):

  Sometimes, you want one specific external class or function to access your private members without making them public to the whole world.

  • Usage: Unit Testing (Test fixture needs to check private state) or tightly coupled classes (e.g., LinkedList accessing Node internals).

  class Box {
  private:
      int secret_data;
      friend class TestSuite; // 'TestSuite' can now touch 'secret_data'
  };

• Struct vs. Class:

  Technically, they are almost identical. The only difference is the default encapsulation level.

  • class: Members are private by default. (Prefers Hiding).
  • struct: Members are public by default. (Prefers Exposure).
  • Best Practice: Use struct for "Plain Old Data" (POD) where there are no invariants to protect (e.g., Coordinate {x, y}). Use class for everything else.

• Maintaining Invariants:

  An invariant is a condition that must always be true.

  • Example: "The Buffer Head index must always be < BUFFER_SIZE".
  • If head is public, user code buf.head++ might overflow. If head is private, the push() function guarantees the wrap-around logic (head = (head + 1) % SIZE).

• Read-Only Hardware:

  Many sensors provide data that should be read but never written to by software.

  • Solution: Make the variable private and provide only a getVal() function. No setVal() means the data is effectively read-only.

• Decoupling Implementation:

  You can change the internal logic without breaking user code.

  • Scenario: You switch from a software timer to a hardware timer.
  • If users accessed the timer_counter variable directly, their code breaks.
  • If users called timer.getTime(), you just update the function body. Their code remains untouched.

The Fear: "Calling getSpeed() adds function call overhead (stack push/pop). Direct access motor.speed is faster."

The Reality: C++ compilers are incredibly smart. If you define the getter in the header file:

// In header
inline float getSpeed() const { return duty_cycle; }

The compiler performs Inlining. It replaces the function call with the direct assembly instruction to read the memory address.

Result: You get the safety of Encapsulation with Zero Performance Penalty.