观察者模式简单实现-代码2

我这里实现了一对多的代码：
个人意见：无论是一对多还是一对一，给模式的价值在于，被观察对象变化，可以自动的通知观察者，我这种状态关系编程一种稳定的依赖，两个对象间形成了一种稳定的依赖，那么实际上是降低了耦合度。
这有点难理解：说得直白点就是，两个对象无论在发生什么样的变化，都不需要考虑对两个依赖的影响，他们俩的灵活性并未因这个稳定的依赖而降低。
#include
#include
#include
using namespace std;

// 类声明
int index=0;
class Subject;
class Observer
{
public:
int observerState;
Subject* subject;
Observer(Subject* s);
bool operator==(Observer& o);
int id;
virtual void Update();
};
class Subject
{
public:
int subjectState;
list mList;
Subject();
void Atatch(Observer o);
void Detach(Observer o);
void Notify();
int getState();
void setState(int state);
};

// 类定义
Observer::Observer(Subject* s){
subject = s;
observerState = 0;
id = index++;
}
bool Observer::operator==(Observer& o)
{
if(o.id == id){
return true;
}else{
return false;
}
}
void Observer::Update(){
observerState = subject->getState();
cout<<“observerState:”<<observerState<<"\n";
}

Subject::Subject(){
subjectState = 0;
}
void Subject::Atatch(Observer o)
{
mList.push_back(o);
}
void Subject::Detach(Observer o)
{
list::iterator iter;
for(iter = mList.begin(); iter != mList.end() ;iter++)
{
if((*iter)== o)
{
mList.erase(iter);
}
}
}
void Subject::Notify(){
list::iterator iter;
for(iter = mList.begin(); iter != mList.end() ;iter++)
{
(*iter).Update();
}
}
int Subject::getState(){
return subjectState;
}
void Subject::setState(int state){
subjectState = state;
Notify();
}

//客户端调用
int main()
{
cout<<“观察者模式演示\n”;
Subject* subject = new Subject();
Observer a(subject);
Observer b(subject);
Observer c(subject);
subject->Atatch(a);
subject->Atatch(b);
subject->Atatch©;
subject->setState(5);

//看代码不用考虑以下内容
int cin_a;
cin>>cin_a;
return 0;

}