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& clock;

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

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

    void writeReg(int offset, int value) {
        clock.write(offset,value);
    }
};

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

public:
    Driver() : clock(), peripheral(clock) {
        cout << "Driver started" << endl;
    }

    void operate(int offset, int value) {
        peripheral.writeReg(offset, value);
    }

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

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

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

    return 0;
}

Solving Approach