适配器模式C语言实现

最新推荐文章于 2024-08-22 09:50:06 发布
最新推荐文章于 2024-08-22 09:50:06 发布
阅读量4.1k 收藏 1
点赞数
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tandesir/article/details/8642948
版权
这篇博客介绍了如何用C语言实现适配器模式，提供了包括`forwardplayer`、`centerplayer`、`guardsplayer`、`foreigncenterplayer`以及适配器`foreigncenteradapter`的源码，并附带测试文件`test.c`和`Makefile`。作者鼓励读者下载源码进行学习和交流。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

【说明】适配器模式的C语言实现，改写自http://blog.youkuaiyun.com/sx_wpc/article/details/7688128一文的代码。

【代码清单】

typedef.h

#ifndef __TYPEDEF_H__
#define __TYPEDEF_H__

#include <stdio.h>
#include <stdlib.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef enum _Ret
{
	RET_OK,
	RET_FAIL
}Ret;

#define return_if_fail(p)\
	if(!(p)){\
	printf("%s:%d Warning:"#p"Failed\n",__func__,__LINE__);\
	return;}
#define return_val_if_fail(p, ret)\
	if(!(p)){\
	printf("%s:%d Warning:"#p"Failed\n",__func__,__LINE__);\
	return (ret);}
#define SAFE_FREE(p) if(p != NULL){free(p); p = NULL;}

#ifdef __cplusplus
}
#endif

#endif


player.h

#ifndef __PLAYER_H__
#define __PLAYER_H__

#include "typedef.h"

#ifdef __cplusplus
extern "C" {
#endif

struct _Player;
typedef struct _Player Player;

struct _Player
{
	char *name;
	void (*attack)(void *player);
	void (*defend)(void *player);
	void (*destroy)(void *player);
};

static inline void player_attack(Player *thiz)
{
	return_if_fail(thiz != NULL);
	if(thiz->attack != NULL)
	{
		thiz->attack(thiz);
	}
}

static inline void player_defend(Player *thiz)
{
	return_if_fail(thiz != NULL);
	if(thiz->defend != NULL)
	{
		thiz->defend(thiz);
	}
}

static inline void player_destroy(Player *thiz)
{
	return_if_fail(thiz != NULL);
	if(thiz->destroy != NULL)
	{
		thiz->destroy(thiz);
	}
}

#ifdef __cplusplus
}
#endif

#endif


forwardsplayer.h

#ifndef __FORWARDSPLAYER_H__
#define __FORWARDSPLAYER_H__

#include "player.h"

#ifdef __cplusplus
extern "C" {
#endif

struct _Forwards;
typedef struct _Forwards Forwards;

struct _Forwards
{
	Player player;
};

Forwards *ForwardsCreate(char *name);

#ifdef __cplusplus
}
#endif

#endif

 

forwardsplayer.c

#include <stdio.h>
#include <stdlib.h>
#include "forwardsplayer.h"

static void forwards_attack(void *thiz)
{
	printf("前锋 %s 进攻\n", ((Forwards *)thiz)->player.name);
}

static void forwards_defend(void *thiz)
{
	printf("前锋 %s 防守\n", ((Forwards *)thiz)->player.name);
}

static void forwards_destroy(void *thiz)
{
	return_if_fail(thiz !=  NULL);
	SAFE_FREE(thiz);
}

Forwards *ForwardsCreate(char *name)
{
	Forwards *thiz = malloc(sizeof(Forwards));

	if(thiz != NULL)
	{
		thiz->player.name = name;
		thiz->player.attack = forwards_attack;
		thiz->player.defend = forwards_defend;
		thiz->player.destroy = forwards_destroy;
	}
	
	//printf("%s\n", thiz->player->name);	

	return thiz;
}


centerplayer.h

#ifndef __CENTERPLAYER_H__
#define __CENTERPLAYER_H__

#include "player.h"

#ifdef __cplusplus
extern "C" {
#endif

struct _Center;
typedef struct _Center Center;

struct _Center
{
	Player player;
};

Center *CenterCreate(char *name);

#ifdef __cplusplus
}
#endif

#endif


centerplayer.c

#include <stdio.h>
#include <stdlib.h>
#include "centerplayer.h"

static void center_attack(void *thiz)
{
	printf("中锋 %s 进攻\n", ((Center *)thiz)->player.name);
}

static void center_defend(void *thiz)
{
	printf("中锋 %s 防守\n", ((Center *)thiz)->player.name);
}

static void center_destroy(void *thiz)
{
	return_if_fail(thiz !=  NULL);
	SAFE_FREE(thiz);
}

Center *CenterCreate(char *name)
{
	Center *thiz = malloc(sizeof(Center));

	if(thiz != NULL)
	{
		thiz->player.name = name;
		thiz->player.attack = center_attack;
		thiz->player.defend = center_defend;
		thiz->player.destroy = center_destroy;
	}
	
	return thiz;
}


guardsplayer.h

#ifndef __GUARDSPLAYER_H__
#define __GUARDSPLAYER_H__

#include "player.h"

#ifdef __cplusplus
extern "C" {
#endif

struct _Guards;
typedef struct _Guards Guards;

struct _Guards
{
	Player player;
};

Guards *GuardsCreate(char *name);

#ifdef __cplusplus
}
#endif

#endif

 

guardsplayer.c

#include <stdio.h>
#include <stdlib.h>
#include "guardsplayer.h"

static void guards_attack(void *thiz)
{
	printf("后卫 %s 进攻\n", ((Guards *)thiz)->player.name);
}

static void guards_defend(void *thiz)
{
	printf("后卫 %s 防守\n", ((Guards *)thiz)->player.name);
}

static void guards_destroy(void *thiz)
{
	return_if_fail(thiz !=  NULL);
	SAFE_FREE(thiz);
}

Guards *GuardsCreate(char *name)
{
	Guards *thiz = malloc(sizeof(Guards));

	if(thiz != NULL)
	{
		thiz->player.name = name;
		thiz->player.attack = guards_attack;
		thiz->player.defend = guards_defend;
		thiz->player.destroy = guards_destroy;
	}
	
	return thiz;
}


foreigncenterplayer.h

#ifndef __FORIGNCENTERPLAYER_H__
#define __FORIGNCENTERPLAYER_H__

#include "typedef.h"

#ifdef __cplusplus
extern "C" {
#endif

struct _ForeignCenter;
typedef struct _ForeignCenter ForeignCenter;

struct _ForeignCenter
{
	char *name;
	void (*fattack)(void *player);
	void (*fdefend)(void *player);
	void (*fdestroy)(void *player);
};

void foreign_center_attack(void *thiz);
void foreign_center_defend(void *thiz);
void foreign_center_destroy(void *thiz);

#ifdef __cplusplus
}
#endif

#endif


foreigncenterplayer.c

#include <stdio.h>
#include <stdlib.h>
#include "foreigncenterplayer.h"

void foreign_center_attack(void *thiz)
{
	printf("外籍中锋 %s 进攻\n", ((ForeignCenter *)thiz)->name);
}

void foreign_center_defend(void *thiz)
{
	printf("外籍中锋 %s 防守\n", ((ForeignCenter *)thiz)->name);
}

void foreign_center_destroy(void *thiz)
{
	return_if_fail(thiz !=  NULL);
	SAFE_FREE(thiz);
}

static ForeignCenter *ForeignCenterCreate(char *name)
{
	ForeignCenter *thiz = malloc(sizeof(ForeignCenter));

	if(thiz != NULL)
	{
		thiz->name = name;
		thiz->fattack = foreign_center_attack;
		thiz->fdefend = foreign_center_defend;
		thiz->fdestroy = foreign_center_destroy;
	}
	
	return thiz;
}


foreigncenteradapter.h

#ifndef __FORIGNCENTERADAPTER_H__
#define __FORIGNCENTERADAPTER_H__

#include "player.h"

#ifdef __cplusplus
extern "C" {
#endif

struct _ForeignCenterAdapter;
typedef struct _ForeignCenterAdapter ForeignCenterAdapter;

struct _ForeignCenterAdapter
{
	Player player;
};

ForeignCenterAdapter *ForeignCenterAdapterCreate(char *name);

#ifdef __cplusplus
}
#endif

#endif

 

foreigncenteradapter.c

#include <stdio.h>
#include <stdlib.h>
#include "foreigncenterplayer.h"
#include "foreigncenteradapter.h"

static void foreign_center_adapter_attack(void *thiz)
{
	foreign_center_attack(thiz);
}

static void foreign_center_adapter_defend(void *thiz)
{
	foreign_center_defend(thiz);
}

static void foreign_center_adapter_destroy(void *thiz)
{
	foreign_center_destroy(thiz);
}

ForeignCenterAdapter *ForeignCenterAdapterCreate(char *name)
{
	ForeignCenterAdapter *thiz = malloc(sizeof(ForeignCenterAdapter));

	if(thiz != NULL)
	{
		thiz->player.name = name;
		thiz->player.attack = foreign_center_adapter_attack;
		thiz->player.defend = foreign_center_adapter_defend;
		thiz->player.destroy = foreign_center_adapter_destroy;
	}
	
	return thiz;
}


test.c

#include <stdio.h>
#include <stdlib.h>
#include "player.h"
#include "forwardsplayer.h"
#include "centerplayer.h"
#include "guardsplayer.h"
#include "foreigncenteradapter.h"

int main(int argc, char **argv)
{
	Player *a = (Player *)CenterCreate("姚明");
	player_attack(a);	
	Player *b = (Player *)ForeignCenterAdapterCreate("巴蒂尔");
	player_defend(b);
	player_attack(b);
	player_destroy(a);
	player_destroy(b);
	return 0;
}


Makefile

exe:=test
temp := $(wildcard test *~) 

all:test.c player.h foreigncenteradapter.h foreigncenteradapter.c foreigncenterplayer.h foreigncenterplayer.c forwardsplayer.h forwardsplayer.c  centerplayer.h centerplayer.c guardsplayer.h guardsplayer.c typedef.h
	gcc -g $^ -o $(exe)

clean:
	rm $(temp)


【源码下载】

 

 

*欢迎纠错，共同进步！

 

转载请标明出处，仅供学习交流，勿用于商业目的

Copyright @ http://blog.youkuaiyun.com/tandesir

 

 

嵌入式C语言设计模式 --- 适配器模式
EmbedIoT Studio
01-16 1080
适配器模式（Adapter Pattern），是属于结构型模式的一种，可以作为两种不兼容的接口之间的桥梁，它结合了两个独立接口的功能，并为应用层业务提供统一的接口。在我们的日常生活里面，经常可以看到“适配器”相关的产品，比如：电源适配器，USB接口适配器，显示器接口适配器，等等。
【编程之美】常用于单片机的接口适配器模式C语言实现
李肖遥的专栏
05-10 470
前言通俗的讲，适配器模式是将一个类的接口转换成客户希望的另外一个接口，在我们编写程序的时候，尤其是在我们使用到单片机做项目的时候，经常会用到。但是往往我们做项目写程序的时...
适配器模式（c语言实现）
hope_worker的专栏
06-05 742
在这里用c实现了类似于java的接口。 #include <stdio.h> #include <stdlib.h> #include <cassert> typedef struct _Duck { void (*fly)(struct _Duck* b); void (*quack)(struct _Duck* b); }...
C语言和设计模式（适配器模式）
java开发指南博客 【转载】
12-28 256
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 现在的生活当中，我们离不开各种电子工具。什么笔记本电脑、手机、mp4啊，都离不开充电。既然是充电，那么就需要用到充电器。其实从根本上来说，充电器就是一个个普通的适配器。什么叫适配器呢，就是把220v、50hz的交流电压编程5~12v的直流电压。充电器就干了这么一件事情。 那么，这样的...
经常用到的单片机接口适配器模式C语言实现~
06-02 567
前言通俗地讲，适配器模式是将一个类的接口转换成客户希望的另外一个接口，在我们编写程序的时候，尤其是在我们使用到单片机做项目的时候，经常会用到。但是往往我们做项目写程序的时候，并没有想到那...
适配器模式（C语言） -- already done
weixin_45444963的博客
11-10 621
一、介绍 适配器模式（Adapter Pattern）是作为多个不兼容的模块之间的桥梁。它结合了多个模块的功能。因C语言没有类和继承等特性，所以本文只讨论接口适配器，至于类适配器和对象适配器不在本文讨论范围。例如，在需要解码的程序中，一个上位机（用户）需要跟解码器通信，但是解码器需要能解码不同通信协议的数据包。 二、工作原理 将一个模块的接口转换成另一种接口，转换后的接口可以兼容。 调用者（用户）不需要知道各模块内部的实现，方便增减模块，可以解耦，方便移植 三、适配器图解 四、代码示例 common.
单例模式，适配器模式，迭代器模式，工厂模式(C++实现)
wtl666_6的博客
12-31 6793
设计模式 单例模式，适配器模式，迭代器模式，工厂模式(C++实现)
C语言实现设计模式.zip
06-13
当我们谈论"C语言实现设计模式"时，我们关注的是如何在C这种静态类型、过程式编程语言中应用面向对象的设计原则和最佳实践。C语言虽然不具备像Java或C++那样的内置面向对象特性，但通过巧妙的技巧和结构，我们仍然...
c语言 适配器模式例子,适配器模式C语言实现
weixin_34621309的博客
05-21 230
【代码清单】typedef.h#ifndef __TYPEDEF_H__#define __TYPEDEF_H__#include #include #ifdef __cplusplusextern "C" {#endiftypedef enum _Ret{RET_OK,RET_FAIL}Ret;#define return_if_fail(p)\if(!(p)){\printf("%s:%d W...
嵌入式常用的设计模式——适配器模式的C语言实现
李肖遥的专栏
06-27 590
关注、星标公众号，直达精彩内容来源：pirateeee一、介绍适配器模式（Adapter Pattern）是作为多个不兼容的模块之间的桥梁。它结合了多个模块的功能。因C语言没有类和继承等特性，所以本文只讨论接口适配器，至于类适配器和对象适配器不在本文讨论范围。例如，在需要解码的程序中，一个上位机（用户）需要跟解码器通信，但是解码器需要能解码不同通信协议的数据包。二...
嵌入式C设计模式---适配器设计模式
weixin_42162924的博客
05-04 3055
将一个类的接口转换成客户希望的另一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
常用于单片机的接口适配器模式C语言实现
轻松学C语言
04-27 295
一般实现在我们做项目的时候，一般的实现，可能我们会这样写代码// FileName: test.c// 来源：公众号【技术让梦想更伟大】#include#include “Exte...
设计模式的C语言实现--适配器模式
lbaihao的专栏
06-12 490
将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 你想使用一个已经存在的类，而它的接口不符合你的需求。 你想创建一个可以复用的类，该类可以与其它不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。 （仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。 在单片机C中，该模式用的很少，大概如下： #def...
c语言 适配器模式例子,适配器模式C语言兑现
weixin_29638241的博客
05-21 251
适配器模式C语言实现【说明】适配器模式的C语言实现，改写自http://blog.youkuaiyun.com/sx_wpc/article/details/7688128一文的代码。【代码清单】typedef.h#ifndef __TYPEDEF_H__#define __TYPEDEF_H__#include #include #ifdef __cplusplusextern "C" {#endiftyp...
【知识分享】C语言中的设计模式——适配器、装饰者和代理
知识噬元兽的博客
09-12 1372
适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。此模式应用到C语言中，跟装饰者和代理这两种模式很接近，所以这里把这三个放一起讲，这三种模式在C语言里经常用到，叫做接口封装。
设计模式专题之C语言-适配器模式
最新发布
甜航一直在的博客
08-22 917
适配器模式（Adapter Pattern）是一种结构型设计模式，旨在将一个类的接口转换为客户端希望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的类可以协同工作。简单来说，它就像一个“适配器”，可以让本来不兼容的插头和插座之间建立联系。
C语言和设计模式（2.1适配器模式）
LETFLY'S LAB
03-21 418
1. 适配器模式 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 1.1. 适用性 你想使用一个已经存在的类，而它的接口不符合你的需求。 你想创建一个可以复用的类，该类可以与其它不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。 （仅适用于对象Adapter）你想使...
接口隔离模式之适配器模式（Adapter）
青萍之末的博客
12-24 789
文章目录一、概念二、动机三、适配器模式四、类图结构五、要点总结 一、概念   将一个类的接口转换成客户希望的另一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。—《设计模式》Gof 二、动机   在软件系统中，由于应用环境的变化，常常需要将“一些现存的对象”放在新的环境中应用，但是新环境要求的接口是这些现存对象所不满足的。   如何应对这种“迁移的变化”？如何既...
C语言实现设计模式探索
设计模式包括单件模式、工厂模式、抽象工厂模式、访问者模式、状态模式、命令模式、解释器模式、备忘录模式、观察者模式、桥接模式、建造者模式、中介者模式、策略模式、适配器模式、装饰模式、亨元模式、代理模式、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值