이제 여기서부터는 개선의 여지를 찾아보겠습니다. 어떻게 하면 EventSrc 클래스가 담당하고 있는 Fire 함수를 Observed에게 전가시킬 수 있을까요? 그래서 EventSrc 클래스를 없앨 수 있겠는가? 그 해답은 함수자(Functor)에 있습니다.
먼저 연습겸해서 간단하게 함수자를 사용해서 1단계의 코드를 수정해 보도록 하겠습니다. 아래는 새롭게 추가한 함수자에 대한 클래스입니다.
class Functor {
private:
int arg_;
public:
Functor(int arg) {
arg_ = arg;
}
void operator()(Observable *pOb) const {
pOb->OnEvent(arg_);
}
};
이 함수자를 사용하면, EventSrc 클래스의 Fire 함수가 아래처럼 무척 깔끔하게 작성됩니다.
void Fire(int a)
{
std::for_each(m_listObserver.begin(), m_listObserver.end(), Functor(a));
}
하지만 이런 방식은 Fire 함수를 깔끔하게 만들어준다는 사소한 장점은 있지만, 다른 어플리케이션에 적용할때 매번 함수자를 각각의 경우에 맞게 새롭게 코딩해줘야 하는 수고로움이 더욱 많습니다. 또한 여전이 Observed에서는 자신이 관리하고 있는 Observer 객체들이 호출해야할 함수가 무엇인지를 알 길이 없습니다.
하지만 여기서 곰곰이 생각해 보면 이 함수자를 Observed 클래스의 inner class로 정의해보는 것에 대한 아이디어가 떠오릅니다. 게다가 이 함수자 역시 template로 정의해서 Observed 클래스가 관리하고 있는 Observer 객체들이 호출해야할 함수를 타입으로 받아 버린다면 Observed가 알아야할 Observer의 정보를 모두 Observed에게 넘겨줄 수 있게되어, Fire의 책임을 Observed가 맡을 수 있게 됩니다. 그러면 더 이상 EventSrc는 필요치 않게 되고요. 이러한 아이디어에 착안해서 새롭게 구현된 Observed 클래스는 다음과 같습니다.
template <class T, class T_result, class T_arg1>
class Observed
{
public:
class Firer1 {
public:
explicit Firer1(T_result (T::*pMember)(T_arg1), T_arg1 arg1) {
m_pMemFunc = pMember;
m_arg1 = arg1;
}
T_result operator()(T* pClass) const {
return ((pClass->*m_pMemFunc)(m_arg1));
}
private:
T_result (T::*m_pMemFunc)(T_arg1);
T_arg1 m_arg1;
};
public: // type define
typedef std::list<T *> typeObservers;
protected: // private attribute
typeObservers m_listObserver;
T_result (T::*m_pMemFunc)(T_arg1);
}
public: // ctr & dtr
Observed(T_result (T::*pMember)(T_arg1)) {
m_pMemFunc = pMember;
}
virtual ~Observed() {}
public: // operator
void RegisterObserver(T *pOb)
{
m_listObserver.push_back( pOb );
}
void UnRegisterObserver(T *pOb)
{
m_listObserver.remove(pOb);
}
public: // Fire!
void Fire(T_arg1 arg1)
{
std::for_each(m_listObserver.begin(), m_listObserver.end(),
Firer1(m_pMemFunc, arg1));
}
};
굵은 청색 폰트로 된 것이 수정되거나 새롭게 추가된 것입니다. Observed가 관리하고 있는 Observer의 호출함수의 반환값과 인자, 그리고 호출함수에 대한 타입을 template 인자인 T_result와 T_arg1으로 받고, 호출함수는 생성자에서 받아 맴버변수인 m_pMemFunc에 저장하도록 하였습니다.
이렇게 새롭게 구현된 Observed를 이용해서 Client 측에서 사용하는 코드는 다음과 같습니다.
int _tmain(int argc, _TCHAR* argv[])
{
Observed<Observable, void, int> *pES =
new Observed<IMyObservable, void, int>(&Observable::OnEvent);
Observable_A *pOA = new Observable_A();
Observable_B *pOB = new Observable_B();
pES->RegisterObserver(pOA);
pES->RegisterObserver(pOB);
pES->Fire(99);
delete pOA;
delete pOB;
delete pES;
return 0;
}
이제 마지막으로 하나 더 짚고 정리를 하겠습니다. 여기서 한가지 큰 문제가 있는데 그것은 Observed가 관리하고 있는 Observer의 호출해야할 함수의 인자 개수에 관한 문제입니다. 지금가지의 경우는 단지 하나의 인자만을 받는 경우지만 두개 이상의 인자를 받는 경우에 대한 처리도 필요하지요. 하지만 이것 역시 그리 어렵지 않게 해결할 수 있습니다. Observed의 inner class인 함수자의 이름이 Firer1인 이유는 하나의 인자를 받는 함수자이기 때문에 Firer 뒤에 1을 붙인 것입니다. 그렇다면 이제 2개의 인자를 받는 Firer2 함수자를 정의하고 인자를 2개를 받는 Fire 맴버함수를 하나더 만들어 두면 됩니다.
이제 Client는 1단계처럼 관리하고자 하는 Observer에 대해 EventSrc와 Observable 클래스 모두를 정의할 필요가 없이, Observable 클래스 단하나만 신경 쓰면 되게 되었습니다. 그리고 Observer에 대한 모든 관리에 대한 책임을 오직 Observed가 맡게 되어 SRP를 지키게 되었습니다.
|
