C语言实现《设计模式之禅》之工厂模式——标准工厂

#include 
   
   
    
    
#include 
    
    
     
     
#include 
     
     
      
      

/*标准的工厂模式示例，类图参见设计模式之禅p66*/


/*抽象产品类*/
typedef struct _Human Human;
struct _Human
{
    void (* GetColor)(void);  /*每个人种的皮肤都有颜色*/
    void (* Talk)(void);        /*每个人种都会说话*/
};

/*具体产品类*/
/*黑色人种*/
typedef struct _BlackHuman BlackHuman;
struct _BlackHuman
{
    Human human; /*继承父类*/
    void (* BlackGetColor)(void); 
    void (* BlackTalk)(void);
    void (*BlackHumanDelete)(BlackHuman *pBlackHuman);
};

void BlackGetColor(void)
{
    //do something
	printf("黑人的皮肤是黑色的\n");
}

void BlackTalk(void)
{
    //do something
	printf("黑人会说话\n");

}

void BlackHumanDelete(BlackHuman *pBlackHuman)
{
    if(NULL != pBlackHuman)
    {
        free(pBlackHuman);
        pBlackHuman = NULL;
    }
    return;
}

BlackHuman *CreateBlackHuman(void)
{
    BlackHuman *pBlackHuman = (BlackHuman *)malloc(sizeof(BlackHuman));
    pBlackHuman->BlackGetColor = BlackGetColor;
    pBlackHuman->BlackTalk = BlackTalk;
    pBlackHuman->BlackHumanDelete = BlackHumanDelete;
    pBlackHuman->human.GetColor = pBlackHuman->BlackGetColor;
    pBlackHuman->human.Talk = pBlackHuman->BlackTalk;

    return pBlackHuman;
}

/*白色人种*/
typedef struct _WhiteHuman WhiteHuman;
struct _WhiteHuman
{
    Human human; /*继承父类*/
    void (* WhiteGetColor)(void);
    void (* WhiteTalk)(void);
    void (*WhiteHumanDelete)(WhiteHuman *pWhiteHuman);
};

void WhiteGetColor(void)
{
    //do something
	printf("白人的皮肤是白色的\n");
}

void WhiteTalk(void)
{
    //do something
	printf("白人说话\n");
}

void WhiteHumanDelete(WhiteHuman *pWhiteHuman)
{
    if(NULL != pWhiteHuman)
    {
        free(pWhiteHuman);
        pWhiteHuman = NULL;
    }
    return;
}

WhiteHuman *CreateWhiteHuman(void)
{
    WhiteHuman *pWhiteHuman = (WhiteHuman *)malloc(sizeof(WhiteHuman));
    pWhiteHuman->WhiteGetColor = WhiteGetColor;
    pWhiteHuman->WhiteTalk = WhiteTalk;
    pWhiteHuman->WhiteHumanDelete = WhiteHumanDelete;
    pWhiteHuman->human.GetColor = pWhiteHuman->WhiteGetColor;
    pWhiteHuman->human.Talk = pWhiteHuman->WhiteTalk;

    return pWhiteHuman;
}


/*黄色人种*/
/*代码略*/


/*抽象工厂*/
typedef struct _AbstractFactory AbstractFactory;
struct _AbstractFactory
{
    Human *(*CreateHuman)(char *pString);
};


/*具体工厂*/
typedef struct _HumanFactory HumanFactory;
struct _HumanFactory
{
    AbstractFactory AbHumanFactory;
    Human *(*CreateHuman)(char *pString);
    void (*DeleteHumanFactory)(HumanFactory *pHumanFactory);
};

/*工厂的核心函数*/
Human * CreateHuman(char *pString)
{
    Human *pHuman = NULL; /*工厂生产的对象是人类*/
    
    if(0 == strcmp(pString, "Whiteman")) /*根据生产命令(入参),选择生产不同的产品*/
    {
        pHuman = (Human *)CreateWhiteHuman(); /*生产一个具体产品(白人)，并转换成其父类。 父类出现的地方就可以用子类替换，符合李氏替换原则*/
    }
    else if(0 == strcmp(pString, "Blackman"))
    {
        pHuman = (Human *)CreateBlackHuman();
    }
    else if(0 == strcmp(pString, "Yellowman"))
    {
    }
    else
    {
        printf("create human error\n");
    }

    return pHuman;

}

void DeleteHumanFactory(HumanFactory *pHumanFactory)
{
    if(NULL != pHumanFactory)
    {
        free(pHumanFactory);
        pHumanFactory = NULL;
    }
    return;
}

HumanFactory *CreateHumanFactory(void)
{
    HumanFactory *pHumanFactory = (HumanFactory *)malloc(sizeof(HumanFactory));
    pHumanFactory->CreateHuman = CreateHuman;
    pHumanFactory->DeleteHumanFactory = DeleteHumanFactory;
    pHumanFactory->AbHumanFactory.CreateHuman = pHumanFactory->CreateHuman;
    return pHumanFactory;
}


/*女娲造人场景*/
void main(void)
{
    /*声明阴阳八卦炉，这是一个抽象工厂*/
    AbstractFactory *pYinYangLu = (AbstractFactory *)CreateHumanFactory();
	Human *pwhiteHuman  = NULL;
	Human *pblackHuman = NULL;

    /*对于场景，只需要知道生产什么人种，生产过程无需关心，符合迪米特法则*/

    /*女娲第一次造人，造白人*/
    pwhiteHuman = pYinYangLu->CreateHuman("Whiteman");
    pwhiteHuman->GetColor();    /*无论什么具体产品，此处只依赖于抽象的公共接口(GetColor, Talk), 接口的实现细节无需关心，符合依赖倒置原则*/
    pwhiteHuman->Talk();
	
    /*女娲第二次造人，造黑人*/
    pblackHuman = pYinYangLu->CreateHuman("Blackman");
    pblackHuman->GetColor();
    pblackHuman->Talk();


}