两段关于回调函数及观察者模式的示例代码

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

class Observer
{
public:
    virtual void update() = 0;
    virtual ~Observer() = default;
};

class SelectionSet
{
public:
    void add(Observer *observer)
    {
        m_observers.push_back(observer);
    }

    void remove(Observer *observer)
    {
        m_observers.erase(std::remove(m_observers.begin(), m_observers.end(), observer), m_observers.end());
    }

    void notify()
    {
        for (auto &observer : m_observers)
        {
            observer->update();
        }
    }

    void addItem(int item)
    {
        items.push_back(item);
        notify();
    }

    void removeItem(int item)
    {
        items.erase(std::remove(items.begin(), items.end(), item), items.end());
        notify();
    }

    std::vector<int> getItems()
    {
        return items;
    }

private:
    std::vector<Observer *> m_observers;
    std::vector<int> items;
};

class ConcreateObserver : public Observer
{
public:

    ConcreateObserver(SelectionSet *set) : selectionSet(set)
    {
        selectionSet->add(this);
    }

    ~ConcreateObserver()
    {
        selectionSet->remove(this);
    }

    void update() override
    {
        std::cout << "Selection set changed." << std::endl;
        for (auto item : selectionSet->getItems())
        {
            std::cout << item << " ";
        }
        std::cout << std::endl;
    }

private:
    SelectionSet *selectionSet;
};

int main()
{
    SelectionSet selectionSet;
    ConcreateObserver observer(&selectionSet);
    selectionSet.addItem(1);
    selectionSet.addItem(2);
    selectionSet.addItem(3);
    selectionSet.removeItem(2);
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

typedef std::function<void(const std::vector<int>&)> SelectionChangedCallback;

class SelectionSet
{
public:
    void addChangeListener(const SelectionChangedCallback& callback)
    {
        m_callbacks.push_back(callback);
    }

    void removeChangeListener(const SelectionChangedCallback& callback)
    {
        m_callbacks.erase(std::remove(m_callbacks.begin(), m_callbacks.end(), callback), m_callbacks.end());
    }

    void addItem(int item)
    {
        m_items.push_back(item);
        notifyListeners();
    }

    void removeItem(int item)
    {
        m_items.erase(std::remove(m_items.begin(), m_items.end(), item), m_items.end());
        notifyListeners();
    }

private:

    void notifyListeners()
    {
        for (const auto& callback : m_callbacks)
        {
            callback(m_items);
        }
    }

    std::vector<SelectionChangedCallback> m_callbacks;
    std::vector<int> m_items;
};

int main()
{
    SelectionSet selectionSet;
    selectionSet.addChangeListener([](const std::vector<int>& items) {
        std::cout << "Selection set changed." << std::endl;
        for (auto item : items)
        {
            std::cout << item << " ";
        }
        std::cout << std::endl;
    });
    selectionSet.addItem(1);
    selectionSet.addItem(2);
    selectionSet.addItem(3);
    selectionSet.removeItem(2);
    return 0;
}