C语言实现状态设计模式

#include 
#include 
#include 

#ifndef VIRTUAL
#define VIRTUAL
#endif

#ifndef DELETE
#define DELETE(X)	do { free(X);X = NULL; } while(0)
#endif

#define NEW(TYPE,pInstance,SUBTYPE)	struct TYPE* pInstance = NULL;	\
									struct SUBTYPE* SUBTYPE##instance = (struct SUBTYPE*)malloc(sizeof(struct SUBTYPE));	\
									SUBTYPE##instance->SUBTYPE##_constructor = SUBTYPE##_constructor;	\
									SUBTYPE##instance->SUBTYPE##_constructor(SUBTYPE##instance);pInstance = (struct TYPE*)(SUBTYPE##instance);


struct State* getProphaseState(void);

struct State* getMetaphaseState(void);

struct State* getAnaphaseState(void);

struct State* getEndState(void);

struct War
{
	struct State* m_pState;

	int 	m_nDays;
	
	void 	(*War_constructor)(struct War* /* pThis */);

	void 	(*War_destructor)(struct War* /* pThis */);

	int 	(*War_getDays)(struct War* /* pThis */);

	void 	(*War_setDays)(struct War* /* pThis */,int /* nDays */);

	void 	(*War_setState)(struct War* /* pThis */,struct State* /* pState */);

	void	(*War_exeState)(struct War* /* pThis */);
};

struct State /* base class */
{
    VIRTUAL void (*Action)(struct State* /* pThis */,struct War* /* pWar */);
};

struct EndState /* sub class */
{
	struct State m_nParent;
	void (*EndState_constructor)(struct EndState* /* pThis */);
};

struct AnaphaseState /* sub class */
{
	struct State m_nParent;
	void (*AnaphaseState_constructor)(struct AnaphaseState* /* pThis */);
};

struct MetaphaseState /* sub class */
{
	struct State m_nParent;
	void (*MetaphaseState_constructor)(struct MetaphaseState* /* pThis */);
};

struct ProphaseState
{
	struct State m_nParent;
	void (*ProphaseState_constructor)(struct ProphaseState* /* pThis */);
};

void EndState_Action(struct State* pThis,struct War* pWar)
{
	printf("444\n");
}

void AnaphaseState_Action(struct State* pThis,struct War* pWar)
{
	if(pWar->War_getDays(pWar) < 30)
	{
		printf("333 : %u\n",pWar->War_getDays(pWar));
	}
	else
	{
		pWar->War_setState(pWar,getEndState());
		pWar->War_exeState(pWar);
	}
}

void MetaphaseState_Action(struct State* pThis,struct War* pWar)
{
	if(pWar->War_getDays(pWar) < 20)
	{
		printf("222 : %u\n",pWar->War_getDays(pWar));
	}
	else
	{
		pWar->War_setState(pWar,getAnaphaseState());
		pWar->War_exeState(pWar);
	}
}

void ProphaseState_Action(struct State* pThis,struct War* pWar)
{
	if(pWar->War_getDays(pWar) < 10)
	{
		printf("111 : %u\n",pWar->War_getDays(pWar));
	}
	else
	{
		pWar->War_setState(pWar,getMetaphaseState());
		pWar->War_exeState(pWar);
	}
}

void EndState_constructor(struct EndState* pThis)
{
	pThis->m_nParent.Action = EndState_Action;
}

void AnaphaseState_constructor(struct AnaphaseState* pThis)
{
	pThis->m_nParent.Action = AnaphaseState_Action;
}

void MetaphaseState_constructor(struct MetaphaseState* pThis)
{
	pThis->m_nParent.Action = MetaphaseState_Action;
}

void ProphaseState_constructor(struct ProphaseState* pThis)
{
	pThis->m_nParent.Action = ProphaseState_Action;
}

/* functions releated with the class War */
void War_destructor(struct War* pThis)
{
	if(pThis->m_pState)
	{
		DELETE(pThis->m_pState);
	}
}

int War_getDays(struct War* pThis)
{
	return pThis->m_nDays;
}

void War_setDays(struct War* pThis,int nDays)
{
	pThis->m_nDays = nDays;
}

void War_setState(struct War* pThis,struct State* pState)
{
	if(pThis->m_pState)
	{
		printf("delete %p\n",pThis->m_pState);
		DELETE(pThis->m_pState);
	}
	pThis->m_pState = pState;
}

void War_exeState(struct War* pThis)
{
	pThis->m_pState->Action(pThis->m_pState,pThis);
}

void War_constructor(struct War* pThis)
{
	pThis->m_pState = NULL;
	pThis->m_nDays = 0;
	pThis->War_destructor = War_destructor;
	pThis->War_getDays = War_getDays;
	pThis->War_setDays = War_setDays;
	pThis->War_setState = War_setState;
	pThis->War_exeState = War_exeState;
}

/* get instance */
struct State* getProphaseState(void)
{
	NEW(State,pState,ProphaseState);
	printf("new %p\n",pState);
	return pState;
}

struct State* getMetaphaseState(void)
{
	NEW(State,pState,MetaphaseState);
	printf("new %p\n",pState);
	return pState;
}

struct State* getAnaphaseState(void)
{
	NEW(State,pState,AnaphaseState);
	printf("new %p\n",pState);
	return pState;
}

struct State* getEndState(void)
{
	NEW(State,pState,EndState);
	printf("new %p\n",pState);
	return pState;
}

/*
	test
*/
int main(void)
{
	NEW(War,pWar,War);
	printf("init\n");

	pWar->War_setDays(pWar,0);
	pWar->War_setState(pWar,getProphaseState());
   
	for(int i = 1 ; i < 40 ; i += 1)
    {  
        pWar->War_setDays(pWar,i);
        pWar->War_exeState(pWar);
    }

    pWar->War_destructor(pWar);
    DELETE(pWar);

    system("pause");
	return 0;
}