Clock-Dependent Peripheral Design

#include <iostream>
using namespace std;

class ClockController {
public:
    ClockController() {
        cout << "Clock enabled" << endl;
    }

    ~ClockController() {
        cout << "Clock disabled" << endl;
    }

    void write(int offset, int value) {
        cout << "Clocked write: " << offset << " " << value << endl;
    }
};

class Peripheral {
private:
    // Must depend on an existing clock
    ClockController& pclk;

public:
    // Must not exist without a clock
    Peripheral(ClockController& clk) : pclk(clk) {
        // pclk = clk;
        cout << "Peripheral ready" << endl;
    }

    ~Peripheral() {
        cout << "Peripheral stopped" << endl;
    }

    void writeReg(int offset, int value) {
        // Must use the clock to perform the write
        pclk.write(offset, value);
    }
};

class Driver {
private:
    // Must own the clock
    ClockController dclk;
    // Must construct the peripheral using that clock
    Peripheral dperiph;

public:
    Driver() : dperiph(dclk) {
        // dperiph = Peripheral(&dclk);
        cout << "Driver started" << endl;
    }

    void operate(int offset, int value) {
        // Perform exactly one write
        dperiph.writeReg(offset, value);
    }

    ~Driver() {
        cout << "Driver stopped" << endl;
    }
};

int main() {
    int offset, value;
    cin >> offset >> value;

    {
        Driver drv;
        drv.operate(offset, value);
    }

    return 0;
}