观察者设计模式是一种行为设计模式，用于在对象之间定义一对多的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都能够自动收到通知并更新。

在C++中，可以通过使用多线程来实现将观察者和主题作为独立的进程。下面是一个示例代码，演示了如何实现这种设计模式：

#include 
#include 
#include 
#include 
#include 

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

class Subject {
    std::vector observers;
    int data;
    std::mutex mutex;
    std::condition_variable cv;
    bool newData;

public:
    void attach(Observer* observer) {
        std::lock_guard lock(mutex);
        observers.push_back(observer);
    }

    void detach(Observer* observer) {
        std::lock_guard lock(mutex);
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notifyAll() {
        std::lock_guard lock(mutex);
        newData = true;
        cv.notify_all();
    }

    void updateData(int newData) {
        std::lock_guard lock(mutex);
        data = newData;
        notifyAll();
    }

    void processData() {
        std::unique_lock lock(mutex);
        cv.wait(lock, [this]() { return newData; });
        newData = false;

        for (Observer* observer : observers) {
            observer->update(data);
        }
    }
};

class ConcreteObserver : public Observer {
    int id;

public:
    ConcreteObserver(int id) : id(id) {}

    void update(int data) override {
        std::cout << "Observer " << id << " received data: " << data << std::endl;
    }
};

int main() {
    Subject subject;

    ConcreteObserver observer1(1);
    ConcreteObserver observer2(2);

    subject.attach(&observer1);
    subject.attach(&observer2);

    std::thread observerThread([&]() {
        while (true) {
            subject.processData();
        }
    });

    for (int i = 0; i < 10; ++i) {
        subject.updateData(i);
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    observerThread.join();

    return 0;
}

在上面的代码中，Observer 类定义了一个抽象的观察者接口，并声明了一个 update 方法，用于接收主题发送的数据更新。

Subject 类定义了一个主题，包含了一个观察者列表以及一个数据字段。它提供了 attach 和 detach 方法，用于添加和移除观察者，以及 updateData 方法，用于更新数据并通知所有观察者。notifyAll 方法通过使用条件变量来通知观察者。

ConcreteObserver 类是 Observer 接口的具体实现，它实现了 update 方法来接收并处理主题发送的数据。

在 main 函数中，我们创建了一个主题以及两个具体观察者对象。然后，我们使用 attach 方法将观察者对象添加到主题的观察者列表中。接下来，我们启动一个单独的线程来处理主题的数据更新。在主线程中，我们通过调用 updateData 方法来更新主题的数据，并将数据发送给观察者。最后，我们等待观察者线程结束。

这样，我们就实现了将观察者和主题作为独立的进程的观察者设计模式。每当主题有新的数据更新时，观察者将会收到通知并处理数据。