DP: Observer

The Observer pattern defines a one-to-many dependency between objects so that when one object (the subject) changes state, all its observers are notified automatically.

This pattern is widely used in embedded systems for sensor updates, event handling, UI refresh, and interrupt-driven systems.

  • Event-driven updates
  • Decouples producers from consumers

C Example

c 
#include <stdio.h>

typedef void (*Observer)(int);

void display(int value) {
    printf("Display updated: %d\n", value);
}

void logger(int value) {
    printf("Log value: %d\n", value);
}

void notifyObservers(Observer obs[], int count, int value) {
    for(int i = 0; i < count; i++)
        obs[i](value);
}

int main() {
    Observer observers[] = {display, logger};
    notifyObservers(observers, 2, 42);
}

C++ Example

cpp 
#include <iostream>
#include <vector>
using namespace std;

class Observer {
public:
    virtual void update(int value) = 0;
};

class Display : public Observer {
public:
    void update(int value) override {
        cout << "Display: " << value << endl;
    }
};

class Sensor {
    vector<Observer*> observers;
public:
    void attach(Observer* o) { observers.push_back(o); }
    void setValue(int v) {
        for(auto o : observers) o->update(v);
    }
};

int main() {
    Sensor s;
    Display d;
    s.attach(&d);
    s.setValue(25);
}