gsi

#include "stdafx.h"

#include <iostream>
#include <string>
using namespace std;

//////////////////////////////////////////////////////////////////////////
class GameLevel
{
public:
 static GameLevel* CreateInstance() { return 0; }
 virtual void SimpleAttack() = 0;

protected:
 GameLevel() {}
};

//////////////////////////////////////////////////////////////////////////
class Gamelevel0 : public GameLevel
{
public:
 static GameLevel* CreateInstance()
 {
  if(pInstance == 0) pInstance = new Gamelevel0();
  return pInstance;
 }

 void SimpleAttack() { cout << "Level0 Simple Attack" << endl; }

protected:
 Gamelevel0() {}

private:
 static Gamelevel0 *pInstance;
};
Gamelevel0* Gamelevel0::pInstance = 0;

//////////////////////////////////////////////////////////////////////////
class Gamelevel1 : public GameLevel
{
public:
 static GameLevel* CreateInstance()
 {
  if(pInstance == 0) pInstance = new Gamelevel1();
  return pInstance;
 }

 void SimpleAttack() { cout << "Level1 Simple Attack" << endl; }

protected:
 Gamelevel1() {}

private:
 static Gamelevel1 *pInstance;
};
Gamelevel1* Gamelevel1::pInstance = 0;

//////////////////////////////////////////////////////////////////////////

class GamePlayer
{
public:
 GamePlayer()
 {
  pGameLevel = Gamelevel0::CreateInstance();
 }

 void UpgradeLevel(GameLevel* pLevel)
 {
  pGameLevel = pLevel;
 }

 void SimpleAttack()
 {
  pGameLevel->SimpleAttack();
 }

private:
 GameLevel* pGameLevel;
};

//////////////////////////////////////////////////////////////////////////
int _tmain(int argc, _TCHAR* argv[])
{
 GamePlayer user1;

 user1.SimpleAttack();
 cout << "------------------------------------------" << endl;

 GameLevel* pGameLevel1 = Gamelevel1::CreateInstance();
 user1.UpgradeLevel(pGameLevel1);

 user1.SimpleAttack();

 return 0;
}

// ObserverPattern.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
//

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>

#include <list>
using namespace std;

//////////////////////////////////////////////////////////////////////////
class Subject;
class Observer
{
public:
 virtual ~Observer() {};
 virtual void Update(Subject* theChangedSubject) = 0;

protected:
 Observer() {};
};

//////////////////////////////////////////////////////////////////////////
class Subject
{
public:
 virtual ~Subject() {};

 virtual void Attach(Observer*);
 virtual void Detach(Observer*);
 virtual void Notify();

protected:
 Subject() {};
private:
 list<Observer*> _observers;
};

void Subject::Attach(Observer* o)
{
 _observers.push_back(o);
}

void Subject::Detach(Observer* o)
{
 _observers.remove(o);
}

void Subject::Notify()
{
 list<Observer*>::iterator iter;

 for(iter = _observers.begin(); iter != _observers.end(); ++iter)
 {
  (*iter)->Update(this);
 }
}

//////////////////////////////////////////////////////////////////////////
class ClockTime : public Subject
{
public:
 ClockTime() {}

 virtual int GetHour() { return 0; }
 virtual int GetMinute() { return 0; }
 virtual int GetSecond() { return 0; }

 void Tick();
};

void ClockTime::Tick()
{
 Notify();
}

//////////////////////////////////////////////////////////////////////////
class Output
{
public:
 Output() {}
 virtual ~Output() {}

 void Draw() {
  printf("Output....\n");
 }
};

//////////////////////////////////////////////////////////////////////////
class DigitalClock : public Output, public Observer
{
public:
 DigitalClock(ClockTime*);
 virtual ~DigitalClock();

 virtual void Update (Subject*);
 virtual void Draw();

private:
 ClockTime* _subject;
};

DigitalClock::DigitalClock(ClockTime* s)
{
 _subject = s;
 _subject->Attach(this);
}

DigitalClock::~DigitalClock()
{
 _subject->Detach(this);
}

void DigitalClock::Update(Subject* theChangedSubject)
{
 if(theChangedSubject == _subject)
  Draw();
}

void DigitalClock::Draw()
{
 int hour = _subject->GetHour();
 int minute = _subject->GetMinute();

 Output::Draw();
}

//////////////////////////////////////////////////////////////////////////
class AnalogClock : public Output, public Observer
{
public:
 AnalogClock(ClockTime*);
 virtual ~AnalogClock();
 virtual void Update(Subject*);
 virtual void Draw();

 void TestChange();

private:
 ClockTime* _subject;
};

AnalogClock::AnalogClock(ClockTime* s)
{
 _subject = s;
 _subject->Attach(this);
}

AnalogClock::~AnalogClock()
{
 _subject->Detach(this);
}

void AnalogClock::Update(Subject* theChangedSubject)
{
 if(theChangedSubject == _subject)
  Draw();
}

void AnalogClock::Draw()
{
 int hour = _subject->GetHour();
 int minute = _subject->GetMinute();

 Output::Draw();
}

void AnalogClock::TestChange()
{
 _subject->Notify();
}

/************************************************************************/
/*                                                                      */
/************************************************************************/
int _tmain(int argc, _TCHAR* argv[])
{
 ClockTime* timer = new ClockTime();

 AnalogClock* analogClock = new AnalogClock(timer);
 DigitalClock* digitalclock = new DigitalClock(timer);

 timer->Tick();

 analogClock->TestChange();

 delete timer;
 delete analogClock;
 delete digitalclock;

 return 0;
}