[태그:] template

작성일자

[C++] Template Summary – 3/3

클래스 템플릿도 특수화가 가능하며, 특수화를 위해서는 특수화 대상이 되는 템플릿 클래스가 필요하다. 아래는 대상이 되는 템플릿 클래스와 이를 특정 타입(double)에 대해 특수화 시킨 예이다.

template class BASE {
public:
	T func() {};
};

template<> class BASE {
public:
	int FuNc(float v) {};
};

주지할 점은  기본 대상이 되는 클래스 템플릿인 BASE와 double 타입에 대해 특수화된 클래스 템플릿 BASE는 완전히 별개의 클래스라는 점으로, 위처럼 서로 가지고 있는 맴버에 공통점이 없다.

템플릿 클래스 자체를 특수화하는 경우 뿐만 아니라, 가지고 있는 맴버 함수만을 콕… 지정해서 특수화 하는 것도 가능하다. 아래는 그 예이다.

template class BASE {
public:
    T func() {};
};

template<> int BASE::func()
{
	// another implementation for int type
}

위의 예는 BASE 함수의 func 함수에 대해 T가 int일때에 대한 특수화의 예이다.

템플릿 인자열 변형을 통한 특수화, 즉 클래스 템플릿 부분 특수화의 예

template class CLASS_NAME {}; //
template class CLASS_NAME<T*, T, i> {};     //
template class CLASS_NAME<char, T, 5> {};          //
template class CLASS_NAME<T*, T, 0> {};            //

이 특수화 대상이 되는 원래 클래스 템플릿이며, , , 가 클래스 템플릿 부분 특수화의 경우이다.

클래스 템플릿이 사용되는 경우는 아래와 같다.

CLASS_NAME<int, double, 10> a;

, , 에 대한 실제 사용 예는 아래와 같으며 순서대로 각 , , 에 일치한다.

CLASS_NAME<int*, int, 20> b;
CLASS_NAME<char, float, 5> c;
CLASS_NAME<char*, char, 3> d;

주목할 점은 클래스 템플릿 부분 특화의 경우 특수화 대상이 되는 원래 클래스 템플릿과 템플릿 인자의 개수가 정확히 일치해야한다. 위의 경우 3개로써 <type, type, int value>이다. 또한 , , , 의 템플릿 클래스는 서로 완전이 다른 클래스 라는 점이며, 단지 템플릿을 통한 관계를 유일한 공통점으로 가지고 있다.

작성일자

[C++] Template Summary – 2/3

기본적인 클래스 탬플릿(Class Template)의 정의 예

template  class Stack_Tpl
{
private:
	int size_;
	int top_;
	T *pMem_;

public:
	Stack_Tpl(int size) : size_(size), top_(-1) {
		pMem_ = new T [size];
	}

	~Stack_Tpl()
	{
		delete [] pMem_;
	}

	void push(T v) 
	{
		pMem_[++top_] = v;
	}

	T pop()
	{
		return pMem_[top_--];
	}
};

위처럼 클래스의 정의와 선언을 동시에 하는 경우도 있지만, 선언과 정의를 분리할 경우에 맴버 함수의 정의는 다음과 같다.

template void Stack_Tpl::push(T v) 
{
	pMem_[++top_] = v;
}

위에서 정의된 클래스 템플릿을 사용하는 방법, 즉 클래스 템플릿을 인스턴스화 하여 템플릿 클래스로 만드는 방법은 아래와 같다.

Stack_Tpl s(10);

참고로, 위처럼 템플릿을 사용하지 않으면 해당 타입의 클래스 템플릿 코드가 만들어지지 않는다. 이때 사용하지는 않지만 해당 타입에 대한 코드를 명시적으로 만들도록 하는 방법은 아래와 같다.

template class Stack_Tpl;

클래스 템플릿의 경우 템플릿의 인자에 타입 이외에 값도 들어갈 수 있는데, 그 경우의 예는 아래와 같다. (비록 예의 기능이 의미가 없음에도 그 문법 자체에 염두해 두길 바란다)

template  class someClass
{
public:
	someClass();
};

template someClass<T, N>::someClass()
{
	T v = N;
}

또한  템플릿의 인자는 기본값을 가질 수 있다는 점을 알아 두어 코드 작성에 융통성을 발휘하길 바란다. 예를 들어 위의 someClass 클래스의 경우를 약간 변형해보면..

template  class someClass
{ ...

기본 템플릿 인자의 경우 함수 템플릿에서는 적용할 수 없다는 점을 염두해 두길 바란다.

작성일자

[C++] Template Summary – 1/3

이 문서는 제가 개인적으로 템플릿을 이용해 코딩할때 참고할 만한 자료를 기재해 놓은 것입니다. 템플릿에 대한 전반적인 내용이 아닌 정리라는 점을 염두해 주시길 바랍니다.

먼저 함수 템플릿의 예이다. Type에 상관 없이 두개의 인자를 받아 이 중 최대값을 반환하는 함수 템플릿의 정의.

tpl_decl.h 라는 파일안에 다음과 같은 코드를 정의 한다.

template T max_Tpl(T a, T b)
{
    return (a>b)?a:b;
}

typename 대신에 class를 써도 상관없지만, Type이라는 분명한 의미를 제공한다는 점에서 개인적으로 typename을 선호한다. 이 max_Tpl이라는 템플릿 함수는 헤더파일만…. 존재해야한다는 점이… 늘 걸리긴 했지만, 이제 이런 걸림은 그냥 포기하고 받아 들이기로 했다. 구현을 별도의 cpp 파일로 분리하기 위해 export 라는 예약어가 제공된다고 하나.. Visual C++ 2008에서도 예약어로만 선언되어 있을 뿐 아직 구현되어 지원하지 않는다.

위의 max_Tpl이라는 함수의 활용은 아래와 같다.

#include "tpl_decl.h"

int _tmain(int argc, _TCHAR* argv[])
{
    double max = max_Tpl(100.0, 200.0);

    ...

위의 코드에서 인자가 실수라는 점이 명확하므로 max_Tpl을 간단히 max_Tpl이라고 해도 되나, 템플릿 함수라는 점을 명확하게 하기 위해 을 붙이는 것을 개인적으로 선호한다.

정의한 max_Tpl이라는 함수에 대해 모든 Type에 대해 작동한다고 보장할 수는 없다. 그 하나의 경우로 문자열 타입에 대한 경우인데, 이 경우 문자열 타입에 대해서는 좀더 특별하게 그 구현을 제공해야한다. 그 구현은 마찬가지로 tpl_decl.h 파일에 아래의 코드를 추가한다.

template<> const char* min_Tpl<>(const char* a, const char *b)
{
    return strcmp(a, b)
}

이를 함수 템플릿 특수화라 한다.

작성일자

Template을 이용한 Observer 패턴 – 2단계

이제 여기서부터는 개선의 여지를 찾아보겠습니다. 어떻게 하면 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 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 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 *pES = 
        new Observed(&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를 지키게 되었습니다.