head first读书笔记2

观察者模式

观察者模式主要是为了模块间的松耦合而设计的，定义了一对多的关系，

多个对象都想知道某个事件的情况，那这个情况一有变化，就立刻通知这多个对象贝。

class Observer
{
public:
 virtual void update(int n);
 virtual void output();
private:
 int num;
};

class Observer1 : public Observer
{
public:
 void update(int n);
 void output();
private:
 int num;
};

class Observer2 : public Observer
{
public:
 void update(int n);
 void output();
private:
 int num;
};

void Observer::update(int n)
{
 num = n;
}

void Observer::output()
{
 printf("observer.num =%d/n", num);
}

void Observer1::update(int n)
{
 num = n;
}

void Observer1::output()
{
 printf("observer1.num =%d/n", num);

}

void Observer2::update(int n)
{
 num = n;
}

void Observer2::output()
{
 printf("observer2.num =%d/n", num);
}

//主题
class subject
{
public:
 subject();
 virtual ~subject();
public:
  void AddObserver(Observer *);
  void DelObserver(Observer *);
  void NodifyObserver();

private:
 Observer* ob[32];

 //通知的事件
 int num;
};

subject::subject()
{
 for (int i=0; i<32; i++)
 {
  ob[i] = NULL;
 }

 num = 10;
}
subject::~subject()
{

}
void subject::AddObserver(Observer *pObserver)
{
 if (pObserver != NULL)
 {
  for (int i=0; i<32; i++)
  {
   if (ob[i] == NULL)
   {
    ob[i] = pObserver;
    break;
   }
  }
 }
}

void subject::DelObserver(Observer *pObserver)
{
 if (pObserver != NULL)
 {
  for (int i=0; i<32; i++)
  {
   if (ob[i] == pObserver)
   {
    ob[i] = NULL;
    break;
   }
  }
 }
}

void subject::NodifyObserver()
{
 for (int i=0; i<32; i++)
 {
  Observer *pb = ob[i];
  if (pb != NULL)
  {
   int n = num;
   pb->update(n);
  }
 }
}

 

int _tmain(int argc, _TCHAR* argv[])
{
 Observer *p1 = new Observer1;
 Observer *p2 = new Observer2;

 subject *psubject = new subject;
 psubject->AddObserver(p1);
 psubject->AddObserver(p2);

 psubject->NodifyObserver();

 p1->output();
 p2->output();

 getchar();
 return 0;
}