C语言兑现《大话设计模式》中的适配器模式例程

C语言实现《大话设计模式》中的适配器模式例程
#ifndef __ADAPTER_H__
#define __ADAPTER_H__
#include "rtthread.h"
#include "finsh.h"
//球员类
typedef struct _Player Player;
struct _Player
{
    char *Name;
    void (*Attack)(void *pPlayer);      //进攻
    void (*Defense)(void *pPlayer);     //防守
    void (*Delete)(void *pPlayer);
};
void PlayerDelete(void *pPlayer)
{
    rt_free(pPlayer);
}
Player *PlayerCreate(char *Name, rt_size_t Size)
{
    Player *pPlayer = (Player *)rt_malloc(Size);
    pPlayer->Name = Name;
    pPlayer->Delete = PlayerDelete;
    return pPlayer;
}
//前锋类
typedef struct _Forwards Forwards;
struct _Forwards
{
    Player mPlayer;
};
void ForwardsAttack(void *pForwards)
{
    rt_kprintf("前锋 %s 进攻\n", ((Forwards *)pForwards)->mPlayer.Name);
}
void ForwardsDefense(void *pForwards)
{
    rt_kprintf("前锋 %s 防守\n", ((Forwards *)pForwards)->mPlayer.Name);
}
Forwards *ForwardsCreate(char *Name, rt_size_t Size)
{
    Forwards *pForwards = (Forwards *)PlayerCreate(Name, Size);
    pForwards->mPlayer.Attack = ForwardsAttack;
    pForwards->mPlayer.Defense = ForwardsDefense;
    return pForwards;
}
//中锋类
typedef struct _Center Center;
struct _Center
{
    Player mPlayer;
};
void CenterAttack(void *pCenter)
{
    rt_kprintf("中锋 %s 进攻\n", ((Center *)pCenter)->mPlayer.Name);
}
void CenterDefense(void *pCenter)
{
    rt_kprintf("中锋 %s 防守\n", ((Center *)pCenter)->mPlayer.Name);
}
Center *CenterCreate(char *Name, rt_size_t Size)
{
    Center *pCenter = (Center *)PlayerCreate(Name, Size);
    pCenter->mPlayer.Attack = CenterAttack;
    pCenter->mPlayer.Defense = CenterDefense;
    return pCenter;
}
//后卫类
typedef struct _Guards Guards;
struct _Guards
{
    Player mPlayer;
};
void GuardsAttack(void *pGuards)
{
    rt_kprintf("后卫 %s 进攻\n", ((Guards *)pGuards)->mPlayer.Name);
}
void GuardsDefense(void *pGuards)
{
    rt_kprintf("后卫 %s 防守\n", ((Guards *)pGuards)->mPlayer.Name);
}
Guards *GuardsCreate(char *Name, rt_size_t Size)
{
    Guards *pGuards = (Guards *)PlayerCreate(Name, Size);
    pGuards->mPlayer.Attack = GuardsAttack;
    pGuards->mPlayer.Defense = GuardsDefense;
    return pGuards;
}
//外籍中锋
typedef struct _ForeignCenter ForeignCenter;
struct _ForeignCenter
{
    char *Name;
    void (*JinGong)(void *pForeignCenter);
    void (*FangShou)(void *pForeignCenter);
    void (*Delete)(void *pForeignCenter);
};
void ForeignCenterJinGong(void *pForeignCenter)
{
    rt_kprintf("外籍中锋 %s 进攻\n", ((ForeignCenter *)pForeignCenter)->Name);
}
void ForeignCenterFangShou(void *pForeignCenter)
{
    rt_kprintf("外籍中锋 %s 防守\n", ((ForeignCenter *)pForeignCenter)->Name);
}
void ForeignCenterDelete(void *pForeignCenter)
{
    rt_free(pForeignCenter);
}
ForeignCenter *ForeignCenterCreate(char *Name, rt_size_t Size)
{
    ForeignCenter *pForeignCenter = (ForeignCenter *)rt_malloc(Size);
    pForeignCenter->Name = Name;
    pForeignCenter->JinGong = ForeignCenterJinGong;
    pForeignCenter->FangShou = ForeignCenterFangShou;
    pForeignCenter->Delete = ForeignCenterDelete;
    return pForeignCenter;
}
//翻译者类
typedef struct _Translator Translator;
struct _Translator
{
    Player mPlayer;
    ForeignCenter *pForeignCenter;
};
void TranslatorAttack(void *pTranslator)
{
    ((Translator *)pTranslator)->pForeignCenter->JinGong(((Translator *)pTranslator)->pForeignCenter);
}
void TranslatorDefense(void *pTranslator)
{
    ((Translator *)pTranslator)->pForeignCenter->FangShou(((Translator *)pTranslator)->pForeignCenter);
}
void TranslatorDelete(void *pTranslator)
{
    ForeignCenterDelete(((Translator *)pTranslator)->pForeignCenter);
    rt_free(pTranslator);
}
Translator *TranslatorCreate(char *Name, rt_size_t Size)
{
    Translator *pTranslator = (Translator *)PlayerCreate(Name, Size);
    pTranslator->pForeignCenter = ForeignCenterCreate(Name, sizeof(ForeignCenter));    
    pTranslator->mPlayer.Name = pTranslator->pForeignCenter->Name;
    pTranslator->mPlayer.Attack = TranslatorAttack;
    pTranslator->mPlayer.Defense = TranslatorDefense;
    pTranslator->mPlayer.Delete = TranslatorDelete;
    return pTranslator;
}

#endif

#include "Adapter.h"
//客户端
void Adapter(void)
{
    Player *b = (Player *)ForwardsCreate("巴蒂尔", sizeof(Forwards));
    Player *m = (Player *)GuardsCreate("麦克格雷迪", sizeof(Guards));
    Player *ym = (Player *)TranslatorCreate("姚明", sizeof(Translator));
    
    b->Attack(b);
    m->Attack(m);
    ym->Attack(ym);
    ym->Defense(ym);
    
    b->Delete(b);
    m->Delete(m);
    ym->Delete(ym);
}
FINSH_FUNCTION_EXPORT(Adapter, Adapter Mode);
适配器模式是将不同的接口用接口类进行转换来使用，像例子中的外籍中锋的类跟其它球员的类接口不一样，于是建造了翻译者接口来转换并使用。
C语言兑现《大话设计模式》中的适配器模式例程

相关推荐
