땅을 떠나지 않으면 하늘을 날수 없다

레이어 아키텍쳐 패턴 이다.

POSA1 책에는 OSI Network 7계층을 예제로 설명이 되어 있다. 적절한 예인듯 하다.

레이어 패턴은 약간의 실무 경험이 있다면 자신의 경험에 비추어 비교적 이해가 쉬울것 같다. 이렇게 사용하고 있는 예가 많기 때문이다.

예를 들면, 보통 처음 ADO 를 배울때, MSDN 샘플을 보면 DB 에 Insert 할 데이타를 바로 가공하고 바로 Execute 해서 DB 에 데이타를 추가 한다. (로직 처리나 DB 에 데이타를 읽거나 쓰는 부분이 하나의 Layer 에 존재한다.)

그러나, 우리는 실무에서 그렇게 사용하지 않는다. ADO 를 이용해서 DB 에 데이타를 읽거나 쓰는 작업은 따로 소스를 분리하거나, 라이브러리, DLL 형태로 제작하고 사용 한다.

ADO 를 사용해서 DB 에 데이타를 읽거나 쓰는 Layer 와 실제 데이타를 Server 나 Application 에서 사용하는 로직 Layer 를 구분한다.

Layer 들은 서로 독립적이어야 하며 Interface 를 통해 서로 참조 해야 한다. 그래야 Layer 가 변경되었을 때도 유연하게 대처 할 수 있다. (ADO 가 ODBC 나 MYSQL 로 변경된다고 해도 해당 레이어만 변경 적용할 수 있다.)

struct IAttackType 
{
	virtual void Attack() = 0; 
};  

struct FireAttack : public IAttackType
{    
	void Attack() { cout << "공격: 불을 뿜다 화이아~" << endl; }; 
};  

struct IceAttack : public IAttackType 
{     
	void Attack() { cout << "공격: 얼음 화살 ㄱㄱ" << endl; }; 
};  	

/////////////   
struct IMonster
{    
	void Attack() 
	{
		attack_type_->Attack();
	}	
	IAttackType* attack_type_;  	
};   

struct FireMonster : public IMonster
{     
	FireMonster() {attack_type_ = new FireAttack;};	
};  

struct IceMonster : public IMonster
{     
	IceMonster() {attack_type_ = new IceAttack;};	
};  
/////////////  	


int _tmain(int argc, _TCHAR* argv[])
{    
	IMonster* fire_monster = new FireMonster;
	IMonster* ice_monster  = new IceMonster;

	fire_monster->Attack();
	ice_monster->Attack();
	
	return 0;
}

마지막 생성 패턴이다.
이건 머 말할것도 없다. 유일 객체 생성~ 

struct MonsterManager
{
public:
    MonsterManager() {cout << "This is MonsterManager !!!" << endl;};
};

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

template 
class Singleton
{
public:
    static T* Instance()
    {
        if (NULL == instance_)
        {
            instance_ = new T;
        }
        return instance_;
    }

    static void Release()
    {
        if (instance_) 
        {		
            delete instance_;
            instance_ = NULL;
        }
    }

private:

    static T* instance_;
};

template< class T > T * Singleton::instance_ = NULL;

void main()
{   
    Singleton::Instance();    
    Singleton::Release();
    Singleton::Instance();    
}

struct IAttackType
{    
    virtual void Attack() = 0;
};

struct FireAttack : public IAttackType
{
    void Attack() { cout << "공격: 불을 뿜다 화이아~" << endl; };
};

struct IceAttack : public IAttackType
{
    void Attack() { cout << "공격: 얼음 화살 ㄱㄱ" << endl; };
};

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

struct IDefensType
{
    virtual void Defenns() = 0;
};

struct AvoidDefens : public IDefensType
{
    void Defenns() { cout << "방어: 회피 하기" << endl << endl; };
};

struct IceShieldDefens : public IDefensType
{
    void Defenns() { cout << "방어: 얼음방패 막기" << endl << endl; };
};

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

struct IMonster
{
    IAttackType* attack_type_;
    IDefensType* defens_type_;
};

struct FireMonster : public IMonster
{
    
};

struct IceMonster : public IMonster
{
    
};

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

struct IMonsterProtype
{
    virtual IMonster* Clone() = 0;    
};

struct FireMonster_Creator : public IMonsterProtype
{
    IMonster* Clone()
    {
        FireMonster* monster = new FireMonster;
        monster->attack_type_ = new FireAttack;
        monster->defens_type_ = new AvoidDefens;
        return monster;
    }    
};

struct IceMonster_Creator : public IMonsterProtype
{
    IMonster* Clone()
    {
        IceMonster* monster = new IceMonster;
        monster->attack_type_ = new IceAttack;
        monster->defens_type_ = new IceShieldDefens;
        return monster;
    }    
};

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

void Operation(IMonster* monster)
{
    monster->attack_type_->Attack();
    monster->defens_type_->Defenns();
}

void main()
{   
    IMonsterProtype* FireMonster_Prototype = new FireMonster_Creator;
    IMonsterProtype* IceMonster_Prototype = new IceMonster_Creator;

    IMonster* fire_monster = FireMonster_Prototype->Clone();
    IMonster* ice_monseter  = IceMonster_Prototype->Clone();  

    Operation(fire_monster);
    Operation(ice_monseter);
    
}

struct IAttackType
{    
    virtual void Attack() = 0;
};

struct FireAttack : public IAttackType
{
    void Attack() { cout << "공격: 불을 뿜다 화이아~" << endl; };
};

struct IceAttack : public IAttackType
{
    void Attack() { cout << "공격: 얼음 화살 ㄱㄱ" << endl; };
};

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

struct IDefensType
{
    virtual void Defenns() = 0;
};

struct AvoidDefens : public IDefensType
{
    void Defenns() { cout << "방어: 회피 하기" << endl << endl; };
};

struct IceShieldDefens : public IDefensType
{
    void Defenns() { cout << "방어: 얼음방패 막기" << endl << endl; };
};

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

struct IMonster
{
    IAttackType* attack_type_;
    IDefensType* defens_type_;
};

struct FireMonster : public IMonster
{
    FireMonster()
    {
        attack_type_ = new FireAttack;
        defens_type_ = new AvoidDefens;
    }
};

struct IceMonster : public IMonster
{
    IceMonster()
    {
        attack_type_ = new IceAttack;
        defens_type_ = new IceShieldDefens;
    }
};

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

struct ICreator
{
    virtual IMonster* CreateMonster() = 0;
    virtual void Operation()
    {
        IMonster* monsetr = CreateMonster();
        monsetr->attack_type_->Attack();
        monsetr->defens_type_->Defenns();
    }
};

struct FireMonster_Creator : public ICreator
{
    IMonster* CreateMonster() 
    {
        return new FireMonster;
    }    
};

struct IceMonster_Creator : public ICreator
{
    IMonster* CreateMonster() 
    {
        return new IceMonster;
    } 
};

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

void main()
{   
    ICreator* fire_monster = new FireMonster_Creator;
    fire_monster->Operation();

    ICreator* ice_monster = new IceMonster_Creator;
    ice_monster->Operation();
}