C++ में Event Bus और Observer पैटर्न: कोड के साथ पूरी गाइड

C++ में Event Bus और Observer पैटर्न: थ्योरी से प्रैक्टिस तक

C++ में आधुनिक सॉफ्टवेयर डेवलपमेंट में कम्पोनेंट्स के बीच लूज़ कपलिंग (ढीला जुड़ाव) बहुत महत्वपूर्ण है। Observer पैटर्न और इसका उन्नत रूप Event Bus, ऑब्जेक्ट्स के बीच बिना कड़ी निर्भरता के संवाद स्थापित करने का एक शानदार तरीका प्रदान करते हैं। इस लेख में हम C++ में इन पैटर्न्स को लागू करने, उनके फायदे और सीमाओं को विस्तार से समझेंगे, और प्रैक्टिकल कोड उदाहरण भी देखेंगे।

Observer पैटर्न: क्लासिकल इम्प्लीमेंटेशन

Observer पैटर्न ऑब्जेक्ट्स के बीच "एक-से-अनेक" का रिश्ता बनाता है: जब एक ऑब्जेक्ट (सब्जेक्ट) अपनी स्थिति बदलता है, तो उस पर निर्भर सभी ऑब्जेक्ट्स (ऑब्ज़र्वर्स) को अपने आप सूचना मिल जाती है। C++ में इसका क्लासिकल इम्प्लीमेंटेशन इस प्रकार है:

#include <iostream>
#include <vector>
#include <memory>
#include <algorithm>

// ऑब्ज़र्वर का इंटरफ़ेस
class IObserver {
public:
    virtual ~IObserver() = default;
    virtual void update(const std::string& message) = 0;
};

// एक खास ऑब्ज़र्वर
class ConcreteObserver : public IObserver {
private:
    std::string name;
public:
    explicit ConcreteObserver(const std::string& n) : name(n) {}
    void update(const std::string& message) override {
        std::cout << "[" << name << "] मिला: " << message << std::endl;
    }
};

// सब्जेक्ट (जिसे देखा जा रहा है)
class Subject {
private:
    std::vector<std::shared_ptr<IObserver>> observers;
    std::string state;
public:
    void attach(std::shared_ptr<IObserver> observer) {
        observers.push_back(observer);
    }
    void detach(std::shared_ptr<IObserver> observer) {
        observers.erase(
            std::remove(observers.begin(), observers.end(), observer),
            observers.end()
        );
    }
    void notify() {
        for (auto& observer : observers) {
            observer->update(state);
        }
    }
    void setState(const std::string& newState) {
        state = newState;
        notify();
    }
};

int main() {
    Subject subject;
    auto obs1 = std::make_shared<ConcreteObserver>("पहला ऑब्ज़र्वर");
    auto obs2 = std::make_shared<ConcreteObserver>("दूसरा ऑब्ज़र्वर");
    
    subject.attach(obs1);
    subject.attach(obs2);
    
    subject.setState("पहली घटना हुई!");
    subject.detach(obs1);
    subject.setState("दूसरी घटना, पहले ऑब्ज़र्वर के बिना");
    
    return 0;
}

Event Bus: केंद्रीकृत इवेंट बस

Event Bus, Observer के विचार को आगे बढ़ाता है और संदेशों के आदान-प्रदान के लिए एक केंद्रीकृत तंत्र प्रदान करता है। हर सब्जेक्ट को ऑब्ज़र्वर्स की सूची रखने के बजाय, सभी सब्सक्रिप्शन और पब्लिकेशन एक ही बस के ज़रिए होते हैं। इससे ये फायदे मिलते हैं:

• कपलिंग कम होती है — भेजने वाले और पाने वाले एक-दूसरे के बारे में कुछ नहीं जानते।
• स्केलिंग आसान होती है — मौजूदा कोड में बदलाव किए बिना नए इवेंट टाइप जोड़े जा सकते हैं।
• लचीलापन मिलता है — रनटाइम पर सब्सक्राइबर्स को जोड़ा और हटाया जा सकता है।

C++ में Event Bus का उदाहरण टेम्पलेट्स और std::function के साथ:

#include <iostream>
#include <unordered_map>
#include <functional>
#include <any>
#include <typeindex>
#include <vector>
#include <memory>

// इवेंट के लिए बेस क्लास
struct Event {
    virtual ~Event() = default;
};

// एक खास इवेंट
struct UserLoginEvent : public Event {
    std::string username;
    explicit UserLoginEvent(std::string name) : username(std::move(name)) {}
};

// Event Bus क्लास
class EventBus {
private:
    std::unordered_map<std::type_index, std::vector<std::function<void(const std::any&)>>> handlers;
public:
    template<typename EventType>
    void subscribe(std::function<void(const Event