C ++ Observer设计模式实现

class Observer
{
public:
    virtual ~Observer() {}

    virtual void onNotify(Subject * entity, Event event) = 0;

private:
};

class Subject
{
public:
    Subject() {}

    virtual ~Subject() {}

    void addObserver(Observer* observer)
    {
        if (std::find(_observers.begin(), _observers.end(), observer) == _observers.end())
        {
            _observers.push_back(observer);
        }
    }

    void removeObserver(Observer* observer)
    {
        std::list<Observer*>::iterator it = std::find(_observers.begin(), _observers.end(), observer);
        if (it != _observers.end())
        {
            *it = NULL;
            _eraseQueue.push(it);
        }
    }

protected:
    // I'm passing the Subject, because it allows me to trigger an event
    // on a newly created object, from another class :
    // this->notify(new MyClass(...), MYCLASS_CREATED);
    // It allows me to generate new entities easily
    void notify(Subject * entity, Event event)
    {
        for (std::list<Observer*>::iterator it = _observers.begin(); it != _observers.end(); ++it)
        {
            if (*it != NULL)
                (*it)->onNotify(entity, event);
        }

        while (!_eraseQueue.empty())
        {
            _observers.erase(_eraseQueue.front());
            _eraseQueue.pop();
        }
    }

    void notify(Subject * entity, Event event, Observer* observer)
    {
        if (observer != NULL)
            observer->onNotify(entity, event);
    }

private:
    std::list<Observer*>                        _observers;
    std::queue<std::list<Observer*>::iterator>  _eraseQueue;
};

template <typename T>
class EventHandler : public Observer
{
public:
    virtual ~EventHandler() {}

    virtual void onNotify(Subject * entity, Event event)
    {
        if (dynamic_cast<T*>(this))
        {
            auto it = _actions.find(event);

            if (it != _actions.end())
            {
                (dynamic_cast<T*>(this)->*(it->second))(entity);
            }
        }
    }

protected:
    template <typename U>
    U safe_cast(Subject* entity)
    {
        if (dynamic_cast<U>(entity))
            return (dynamic_cast<U>(entity));
        else
            throw std::exception("Event thrown on not-matching entity");
    }

protected:
    std::map<const Event, void (T::*)(Subject *)>   _actions;
};

MyClass::MyClass()
{
    _actions[GAME_STARTED] = &MyClass::gameStarted;
    _actions[CHARACTER_MOVED] = &MyClass::characterMoved;
}

void MyClass::gameStarted(Subject * entity)
{
    Game* game = safe_cast<Game*>(entity);

    // Do actions on the Game instance
}

void MyClass::characterMoved(Subject * entity)
{
    Character* character = safe_cast<Character*>(entity);

    // Do actions on the Character instance
}

class MyClass : public EventHandler<MyClass>

virtual void onNotify(Subject * entity, Event event)
{
    // Verify that the 'this' pointer is of type T
    if (dynamic_cast<T*>(this))
    {
        // Find the pointer to function corresponding to the 'event' Event if it has been registered
        auto it = _actions.find(event);

        // Check if the pointer to function has been found
        if (it != _actions.end())
        {
            // Calls the method on the dynamically casted 'this' pointer, so that it can
            // generically call private methods on any class inheriting from EventHandler
            (dynamic_cast<T*>(this)->*(it->second))(entity);
        }
    }
}

// MyClass is inheriting from a 'self-templated' EventHandler
class MyClass : public EventHandler<MyClass>
{
public:
    MyClass() {
        // I'm registering in the EventHandler _actions tab the
        // events that this particular class is listening to
        _actions[CHARACTER_MOVED] = &MyClass::characterMoved;
        _actions[CHARACTER_DIED] = &MyClass::characterDied;

        // Some other initialization
    };
    virtual ~MyClass(){}

private:
    void characterMoved(Subject* entity) {
        // I'm converting the generic Subject object to a Character object
        Character* character = safe_cast<Character*>(entity);

        // I'm doing whatever I want with the character that triggered the event
        std::cout << character->getName() << " moved !" << std::endl;
    }
    void characterDied(Subject* entity) {
        // I'm converting the generic Subject object to a Character object
        Character* character = safe_cast<Character*>(entity);

        // I'm doing whatever I want with the character that triggered the event
        std::cout << "Oh no ! " << character->getName() << " died ! RIP" << std::endl;
        delete character;
    }
}

// Subject is a reference
virtual void onNotify(Subject& entity, Event event) = 0;

// Since you registered on a subject the subject 
// will never been NULL so you can safely use a reference.

// The observer can never be NULL  so you can safely pass by reference.
void addObserver(Observer& observer)

// Note:
// You still store the observer as a pointer in your container.
std::list<Observer*>                        _observers;

// So just get the address from the reference.

    {
        *it = NULL;
        _eraseQueue.push(it);
    }

void notify(Subject * entity, Event event)

void notify(Event event)

std::map<const Event, void (T::*)(Subject *)>   _actions;

// I would use:
std::map<const Event, std::function<void(Subject&)>>   _actions;

// In EventHandler:
std::map<const Event, std::function<void(Subject&)>>   _actions;

// Register Handler (in the `Character class`)
_actions[TAKE_DAMAGE] = std::bind(&Character::takeDamage, this);

// So using the `std::function<>` technique you can use methods and
// lambdas. Because the code for calling the code is encapsulated in
// the standard function you don't need to handle the dangerous code
// involved with casting (this is done for you).

auto find = _actions.find(event);
if (find != _actions.end()) {
    find->second(subject, event);
}