A brief introduction to the observer pattern in C++ design patterns

Observer pattern (Observer): defines a one-to-many dependency relationship, allowing multiple observer objects to monitor a certain subject object at the same time. This topic object notifies all observer objects when its state changes, allowing them to update themselves automatically.

Pattern implementation:

[code]//观察者抽象基类
class Observer{
public:
    virtual void Update(int) = 0;
};
//主题、目标
class Subject{
public:
    virtual void Attach(Observer *) = 0;  //重视
    virtual void Detach(Observer *) = 0; //脱离
    virtual void Notify() = 0; //通知
};

class ConcreateObserver: public Observer{
private:
    Subject *m_pSubject;   //1.具体观察者,维护一个指向ConcreteSubject对象的引用2.存储有关状态,这些状态应与目标的状态保持一致
public:                     //3.实现Observer的更新接口以使自身状态与目标的状态保持一致
    ConcreateObserver(Subject *pSubject): m_pSubject(pSubject){}
    void Update(int value){
        std::cout << "ConcreateObserver get the update. New State: " << value << std::endl;
    }
};

class ConcreateObserver2: public Observer{
private:
    Subject *m_pSubject;
public:
    ConcreateObserver2(Subject *pSubject):m_pSubject(pSubject){}
    void Update(int value){
        std::cout << "ConcreateObserver2 get the update. New State: " << value << std::endl;
    }
};

//1.将有关状态存入各ConcreateObserver对象
//2.当它的状态发生改变时,向它的各个观察者发出通知
class ConcreateSubject: public Subject{
private:
    std::list<Observer *> m_ObserverList;
    int m_iState;
public:
    void Attach(Observer *pObserver);
    void Detach(Observer *pObserver);
    void Notify();

    void setState(int state){
        m_iState = state;
    }
};
void ConcreateSubject::Attach(Observer *pObserver){
    m_ObserverList.push_back(pObserver);
}
void ConcreateSubject::Detach(Observer *pObserver){
    m_ObserverList.remove(pObserver);
}
void ConcreateSubject::Notify(){
    std::list<Observer *>::iterator it = m_ObserverList.begin();
    while(it != m_ObserverList.end()){
        (*it)->Update(m_iState);
        ++it;
    }
}

Client:

[code]int main(){
    //Create Subject
    ConcreateSubject *pSubject = new ConcreateSubject();

    //Create Observer
    Observer *pObserver = new ConcreateObserver(pSubject);
    Observer *pObserver2 = new ConcreateObserver2(pSubject);

    //Change the state
    pSubject->setState(2);

    //Register the observer
    pSubject->Attach(pObserver);
    pSubject->Attach(pObserver2);

    pSubject->Notify();  //Output: ConcreateObserver get the update. New State: 2 
                                 //ConcreateObserver2 get the update. New State: 2

    //Unregister the observer
    pSubject->Detach(pObserver);

    pSubject->setState(3);

    pSubject->Notify();  //Output: ConcreateObserver2 get the update. New State: 3

    delete pObserver;
    delete pObserver2;
    delete pSubject;
}

The above is the content of the C++ design pattern brief introduction to the observer pattern. For more related content, please pay attention to PHP Chinese Net (www.php.cn)!