观察者模式

扩展：观察者模式——委托

C++

参考：https://www.cnblogs.com/Galesaur-wcy/p/15905936.html

#include <iostream>
#include <list>
#include <memory>
#include <string>
using namespace std;

// Observer类 抽象观察者,为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口要做更新接口。
// 观察者一般用一个抽象类或者接口实现，更新接口通常包含一个Update()方法 这个方法叫做更新方法。
class Observer
{
public:
    virtual void Update(int) = 0;
    virtual ~Observer() = default;
    virtual void SetName(const string &observerName) final
    {
        m_observerName = observerName;
    }
    virtual string GetName() const final
    {
        return m_observerName;
    }

protected:
    string m_observerName;
};

// Subject类 可翻译为主题或抽象通知者 一般用一个抽象类或者一个接口实现。他把所有对观察者对象的引用保存
// 在一个聚集里,每个主题都可以又任何数量的观察者。抽象主题提供一个接口，可增加或者删除观察者对象
class Subject
{
public:
    virtual void Attach(shared_ptr<Observer>) = 0;
    virtual void Detach(shared_ptr<Observer>) = 0;
    virtual void Notify() = 0;
};

// ConcreteObserver 具体观察者 实现抽象观察角色所要求的更新接口,以便使本身的状态与主题的状态相协调.
// 具体观察者角色可以保存一个指向具体主题对象的引用.具体观察者校色通常用一个具体子类实现
class ConcreteObserver : public Observer
{
public:
    ConcreteObserver(shared_ptr<Subject> pSubject, const string &observerName)
        : m_pSubject(pSubject)
    {
        m_observerName = observerName;
    }
    void Update(int value) override
    {
        cout << "   ConcreteObserver " << m_observerName << " gets the update. New State: " << value << endl;
    }

private:
    shared_ptr<Subject> m_pSubject;
};

class ConcreteObserver2 : public Observer
{
public:
    ConcreteObserver2(shared_ptr<Subject> pSubject, const string &observerName)
        : m_pSubject(pSubject)
    {
        m_observerName = observerName;
    }
    void Update(int value) override
    {
        cout << "   ConcreteObserver2 " << m_observerName << " gets the update. New State: " << value << endl;
    }

private:
    shared_ptr<Subject> m_pSubject;
};

// ConcreteSubject类，叫做具体主题或者具体通知者..将有关状态存入具体观察者对象；在具体主题内部状态改变时...给所有登记过的观察者发出通知.
// 具体主题对象通常用一个具体子类实现.
class ConcreteSubject : public Subject
{
public:
    void Attach(shared_ptr<Observer> pObserver)
    {
        m_ObserverList.push_back(pObserver);
    }
    void Detach(shared_ptr<Observer> pObserver)
    {
        m_ObserverList.remove_if([=](const shared_ptr<Observer> &observer)
                                 { return observer == pObserver; });
    }
    void Notify()
    {
        for (const auto &observer : m_ObserverList)
        {
            cout << "   Notifying -> " << observer->GetName() << endl;
            observer->Update(m_iState);
        }
    }

    void SetState(int state)
    {
        cout << "State changed to " << state << endl;
        m_iState = state;
    }

private:
    list<shared_ptr<Observer>> m_ObserverList;
    int m_iState;
};

int main()
{
    auto pSubject = make_shared<ConcreteSubject>();

    auto pObserver = make_shared<ConcreteObserver>(pSubject, "observer1");
    auto pObserver2 = make_shared<ConcreteObserver2>(pSubject, "observer2");

    pSubject->Attach(pObserver);
    pSubject->Attach(pObserver2);

    pSubject->SetState(2);
    pSubject->Notify();
    cout << endl;

    pSubject->Detach(pObserver);

    pSubject->SetState(3);
    pSubject->Notify();
    cout << endl;

    return 0;
}

C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

typedef struct Subject Subject;
typedef struct Observer
{
    char *name;
    void (*update)(struct Subject *, int, void *);
} Observer;

typedef struct Subject
{
    struct Observer **observers;
    size_t observer_count;
    int state;
} Subject;

void ConcreteObserverUpdate(struct Subject *subject, int value, void *data)
{
    printf("   ConcreteObserver get the update. New State: %d\n", value);
}

void ConcreteObserver2Update(struct Subject *subject, int value, void *data)
{
    printf("   ConcreteObserver2 get the update. New State: %d\n", value);
}

void attach(struct Subject *subject, Observer *observer)
{
    Observer **newObservers = realloc(subject->observers, sizeof(Observer *) * (subject->observer_count + 1));
    if (newObservers == NULL)
    {
        fprintf(stderr, "Memory allocation failed.\n");
        exit(EXIT_FAILURE);
    }
    newObservers[subject->observer_count++] = observer;
    subject->observers = newObservers;
}

void detach(struct Subject *subject, Observer *observer)
{
    bool removed = false;
    int i;
    for (i = 0; i < subject->observer_count; ++i)
    {
        if (subject->observers[i] == observer)
        {
            subject->observer_count--;
            removed = true;
            int j;
            for (j = i; j < subject->observer_count; ++j)
            {
                subject->observers[j] = subject->observers[j + 1];
            }
            break;
        }
    }
    if (!removed)
    {
        fprintf(stderr, "Observer not found.\n");
    }
}

void notify(struct Subject *subject)
{
    int i;
    for (i = 0; i < subject->observer_count; ++i)
    {
        printf("   Notifying -> %s\n", subject->observers[i]->name);
        subject->observers[i]->update(subject, subject->state, subject->observers[i]);
    }
}

void setState(struct Subject *subject, int state)
{
    printf("state changed......\n");
    subject->state = state;
}

void safe_free(void *ptr)
{
    if (ptr)
        free(ptr);
}

int main()
{
    Subject *pSubject = (Subject *)malloc(sizeof(Subject));
    pSubject->observers = NULL;
    pSubject->observer_count = 0;
    pSubject->state = 0;

    Observer observer1 = {
        .name = strdup("observer1"),
        observer1.update = ConcreteObserverUpdate,
    };

    Observer observer2 = {
        .name = strdup("observer2"),
        .update = ConcreteObserver2Update,
    };

    attach(pSubject, &observer1);
    attach(pSubject, &observer2);

    setState(pSubject, 2);
    notify(pSubject);
    printf("\n");

    detach(pSubject, &observer1);

    setState(pSubject, 3);
    notify(pSubject);
    printf("\n");

    safe_free(observer1.name);
    safe_free(observer2.name);
    safe_free(pSubject->observers);
    safe_free(pSubject);

    return 0;
}