adapter（适配器模式）

最新推荐文章于 2023-05-12 17:01:26 发布
最新推荐文章于 2023-05-12 17:01:26 发布
阅读量522 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hn_zhangkun/article/details/10023271
版权

1、定义

         将一个类的接口转换成客户所希望的另一个接口。adapter模式使得原本由于接口不兼容而不能在一起工作的类可以一起工作。

2、结构

     对象适配器依赖于对象组合

  

3、协作角色

         Target：供客户断掉用的接口

         Adapter： 适配Target和Adaptee

        Adaptee：已经存在的接口

4、适用性

   想使用一个已存在的库，但是接口不兼容

5、实例：

     1、需求，现在已存在一个画图的库，但是另外一个套UI接口不匹配，需要写一个adapter将他们适配到一起。

      2、实现，选其中一个画线的函数做示例

common.h

#ifndef __COMMON_H__
#define __COMMON_H__

#define RET_SUCCESS		0
#define	RET_FAIL		(-1)

typedef unsigned short	WORD;
typedef unsigned int	DWORD;

typedef struct
{
	WORD x1;
	WORD y1;
	WORD x2;
	WORD y2; 
}RECT;

typedef struct {
	WORD Width;
	WORD Height;
	char *data;
}bitmap, *pbitmap;

typedef struct 
{
	void (*draw_line_16bit)(WORD x1, WORD y1, WORD x2, WORD y2, WORD color,bitmap *gbitmap);
	void (*draw_line_32bit)(WORD x1, WORD y1, WORD x2, WORD y2, DWORD color,bitmap *gbitmap);
}iAdapatee;


#endif


adaptee.h

#ifndef __ADAPTEE_H__
#define __ADAPTEE_H__

void draw_line_16bit(WORD x1, WORD y1, WORD x2, WORD y2, WORD color,bitmap *gbitmap);
void draw_line_32bit(WORD x1, WORD y1, WORD x2, WORD y2, DWORD color,bitmap *gbitmap);

#endif


 

adaptee.c

#include <stdio.h>
#include "common.h"
#include "adaptee.h"

WORD Abs(WORD x)
{
	if(x < 0) return (-x);

    return x;
}

void draw_line_16bit(WORD x1, WORD y1, WORD x2, WORD y2, WORD color,bitmap *gbitmap)
{
	int i,p,n,x,y,tn;
	WORD *ptr;

	if(y1 == y2)	//horiziontal line
	{
		if(x1 > x2) { x=x2; x2=x1; x1=x; }
		if(x1 >= gbitmap->Width)
			return;
		if(x2 >= gbitmap->Width)
			x2 = gbitmap->Width-1;

		ptr = (WORD *)gbitmap->data;
		ptr += y1*gbitmap->Width+x1;

		for(i=x1; i<x2; i++) 
			*ptr++ = color;

		return;
	}
	
	if(x1 == x2)	//vertical line
	{
		if(y1 > y2) { y=y2; y2=y1; y1=y; }
		if(y1 >= gbitmap->Height)
			return;
		if(y2 >= gbitmap->Height)
			y2 = gbitmap->Height-1;

		ptr = (WORD *)gbitmap->data;
		ptr += y1*gbitmap->Width+x1;
		for(i=0;i<(y2-y1);i++)
		{
			*ptr = color;
			ptr += gbitmap->Width;
		}
		
		return;
	}
	
	if(Abs(y2-y1) <= Abs(x2-x1))
	{
		if(((y2<y1) && (x2<x1)) || ((y1<=y2) && (x1>x2)))
		{
			x=x2; y=y2; x2=x1; y2=y1; x1=x; y1=y;
		}
		if((y2>=y1) && (x2>=x1))
		{
			x=x2-x1; y=y2-y1;
			p=2*y; n=2*x-2*y; tn=x;
			ptr = (WORD *)gbitmap->data;
			ptr += y1*gbitmap->Width;
			while(x1<=x2)
			{
				if(tn >= 0) tn-=p;
				else { tn+=n; y1++; ptr+=gbitmap->Width; }
				*(ptr+x1++) = color;
			}
		}
		else
		{
			x=x2-x1; y=y2-y1;
			p=-2*y; n=2*x+2*y; tn=x;
			ptr = (WORD *)gbitmap->data;
			ptr += y1*gbitmap->Width;
			while(x1<=x2)
			{
				if(tn>=0) tn-=p;
				else { tn+=n; y1--; ptr-=gbitmap->Width; }
				*(ptr+x1++) = color;
			}
		}
	}
	else
	{
		x=x1; x1=y2; y2=x; y=y1; y1=x2; x2=y;
		if(((y2<y1) && (x2<x1)) || ((y1<=y2) && (x1>x2)))
		{
			x=x2; y=y2; x2=x1; y2=y1; x1=x; y1=y;
		}
		if((y2>=y1) && (x2>=x1))
		{
			x=x2-x1; y=y2-y1; p=2*y; n=2*x-2*y; tn=x;
			ptr = (WORD *)gbitmap->data;
			ptr += x1*gbitmap->Width;
			while(x1<=x2)
			{
				if(tn>=0) tn-=p;
	 			else { tn+=n; y1++; }
				*(ptr+y1) = color;
				ptr += gbitmap->Width;
				x1++;
			}
		}
		else
		{
			x=x2-x1; y=y2-y1; p=-2*y; n=2*x+2*y; tn=x;
			ptr = (WORD *)gbitmap->data;
			ptr += x1*gbitmap->Width;
			while(x1<=x2)
			{
				if(tn>=0) tn-=p;
	 			else { tn+=n; y1--; }
				*(ptr+y1) = color;
				ptr += gbitmap->Width;
				x1++;
			}
		}
	}
}




void draw_line_32bit(WORD x1, WORD y1, WORD x2, WORD y2, DWORD color,bitmap *gbitmap)
{
	int i,p,n,x,y,tn;
	DWORD *ptr;

	if(y1 == y2)	//horiziontal line
	{
		if(x1 > x2) { x=x2; x2=x1; x1=x; }
		if(x1 >= gbitmap->Width)
			return;
		if(x2 >= gbitmap->Width)
			x2 = gbitmap->Width-1;

		ptr = (DWORD *)gbitmap->data;
		ptr += y1*gbitmap->Width+x1;

		for(i=x1; i<x2; i++) 
			*ptr++ = color;

		return;
	}

	if(x1 == x2)	//vertical line
	{
		if(y1 > y2) { y=y2; y2=y1; y1=y; }
		if(y1 >= gbitmap->Height)
			return;
		if(y2 >= gbitmap->Height)
			y2 = gbitmap->Height-1;

		ptr = (DWORD *)gbitmap->data;
		ptr += y1*gbitmap->Width+x1;
		for(i=0;i<(y2-y1);i++)
		{
			*ptr = color;
			ptr += gbitmap->Width;
		}
		
		return;
	}
	
	if(Abs(y2-y1) <= Abs(x2-x1))
	{
		if(((y2<y1) && (x2<x1)) || ((y1<=y2) && (x1>x2)))
		{
			x=x2; y=y2; x2=x1; y2=y1; x1=x; y1=y;
		}
		if((y2>=y1) && (x2>=x1))
		{
			x=x2-x1; y=y2-y1;
			p=2*y; n=2*x-2*y; tn=x;
			ptr = (DWORD *)gbitmap->data;
			ptr += y1*gbitmap->Width;
			while(x1<=x2)
			{
				if(tn >= 0) tn-=p;
				else { tn+=n; y1++; ptr+=gbitmap->Width; }
				*(ptr+x1++) = color;
			}
		}
		else
		{
			x=x2-x1; y=y2-y1;
			p=-2*y; n=2*x+2*y; tn=x;
			ptr = (DWORD *)gbitmap->data;
			ptr += y1*gbitmap->Width;
			while(x1<=x2)
			{
				if(tn>=0) tn-=p;
				else { tn+=n; y1--; ptr-=gbitmap->Width; }
				*(ptr+x1++) = color;
			}
		}
	}
	else
	{
		x=x1; x1=y2; y2=x; y=y1; y1=x2; x2=y;
		if(((y2<y1) && (x2<x1)) || ((y1<=y2) && (x1>x2)))
		{
			x=x2; y=y2; x2=x1; y2=y1; x1=x; y1=y;
		}
		if((y2>=y1) && (x2>=x1))
		{
			x=x2-x1; y=y2-y1; p=2*y; n=2*x-2*y; tn=x;
			ptr = (DWORD *)gbitmap->data;
			ptr += x1*gbitmap->Width;
			while(x1<=x2)
			{
				if(tn>=0) tn-=p;
	 			else { tn+=n; y1++; }
				*(ptr+y1) = color;
				ptr += gbitmap->Width;
				x1++;
			}
		}
		else
		{
			x=x2-x1; y=y2-y1; p=-2*y; n=2*x+2*y; tn=x;
			ptr = (DWORD *)gbitmap->data;
			ptr += x1*gbitmap->Width;
			while(x1<=x2)
			{
				if(tn>=0) tn-=p;
	 			else { tn+=n; y1--; }
				*(ptr+y1) = color;
				ptr += gbitmap->Width;
				x1++;
			}
		}
	}
}

 

adapter.c

#include <stdio.h>
#include "common.h"
#include "adaptee.h"
#include "target.h"

iAdapatee g_Fuc = {NULL, NULL};
int adapter_init()
{
	g_Fuc.draw_line_16bit = draw_line_16bit;
	g_Fuc.draw_line_32bit = draw_line_32bit;
}

int drawline16(RECT *rect, WORD color,bitmap *gbitmap)
{
	WORD x1, y1, x2, y2;
	x1 = rect->x1;
	x2 = rect->x2;
	y1 = rect->y1;
	y2 = rect->y2;
	
	if(g_Fuc.draw_line_16bit)
		g_Fuc.draw_line_16bit(x1, y1, x2, y2, color, gbitmap);
	else
		return RET_FAIL;
		
	return RET_SUCCESS;
}

int drawline32(RECT *rect, DWORD color,bitmap *gbitmap)
{
	WORD x1, y1, x2, y2;
	x1 = rect->x1;
	x2 = rect->x2;
	y1 = rect->y1;
	y2 = rect->y2;
	
	if(g_Fuc.draw_line_32bit)
		g_Fuc.draw_line_32bit(x1, y1, x2, y2, color, gbitmap);
	else
		return RET_FAIL;
		
	return RET_SUCCESS;
}


target.h

#ifndef __TARGET_H__
#define __TARGET_H__

int adapter_init();
int drawline16(RECT *rect, WORD color,bitmap *gbitmap);
int drawline32(RECT *rect, DWORD color,bitmap *gbitmap);

#endif


client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "common.h"
#include "target.h"

void main()
{
	RECT rect;
	bitmap gbitmap;
	unsigned int i,j;
	gbitmap.Width = 32;
	gbitmap.Height = 18;
	char *pwdata;
	char *pdwdata;
	WORD wcolor = ('*' << 8)|'*';
	DWORD dwcolor = ('*' << 24)|('*' << 16)|('*' << 8)|'*';
	
	//test 16bit
	
	adapter_init();
	rect.x1 = 5;
	rect.y1 = 6;
	rect.x2 = 3;
	rect.y2 = 10;

	gbitmap.data = malloc(gbitmap.Width*gbitmap.Height*2);
	memset((void *)gbitmap.data, 0, gbitmap.Width*gbitmap.Height*2);
	drawline16(&rect, wcolor, &gbitmap);
	pwdata = (char *)gbitmap.data;
	for(i = 0; i < gbitmap.Height; i++)
	{
		for(j = 0; j < gbitmap.Width*2; j++)
		{
			printf("%c ",*pwdata++);
		}
		printf("\n");
	}
	free(gbitmap.data);
	
	//test 32bit
	gbitmap.data = malloc(gbitmap.Width*gbitmap.Height*4);
	memset((void *)gbitmap.data, 0, gbitmap.Width*gbitmap.Height*4);
	drawline32(&rect, dwcolor, &gbitmap);
	pdwdata = (char *)gbitmap.data;
	for(i = 0; i < gbitmap.Height; i++)
	{
		for(j = 0; j < gbitmap.Width*4; j++)
		{
			printf("%c ",*pdwdata++);
		}
		printf("\n");
	}	
	free(gbitmap.data);
}


 

 

 


 

专注&突破
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
适配ListView的几种常见Adapter的用法总结
在折腾的年纪里的瞎折腾
09-07 3019
万事开头难
Linux中的I2C(二)——adapter的初始化
choiyoung87的专栏
12-01 1836
I2C adapter init流程分析 1. 前言 I2C adapter作为一条I2C总线的适配器，提供访问其总线上的device的方法，CPU要通过它才能访问到这些device。有兴趣的话可以下载《I2C总线协议》去研究，这些在本文中尚未提及，只是在Linux的I2C的整个架构的角度去描述的。I2C虽然很大程度上已经像经典的Linux设备模型靠拢，但是还是有些地方具有自己的特色。
Adapter（适配器）模式总结
woody218的博客
03-07 684
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
[Android源码分析]bluez中adapter初始化分析
836811384
11-20 399
作为一个程序员，咋废话就不多说了，直接看代码吧，哈哈~~ 2）adapter的初始化 gboolean adapter_init(struct btd_adapter *adapter) { int err; /* adapter_ops makes sure that newly registered adapters always * start off as po...
adapter的两种实现
guang11cheng的专栏
07-24 438
<br />// adapter_class.cpp<br />#include <stdio.h><br />#ifdef _X_RELEASE_ <br />    #define TRACE(str)<br />#else<br />    #define TRACE(str) printf("%s/n", str)<br />#endif<br />// 被适配者<br />class CAdaptee<br />{<br />public:<br />    CAdaptee()<br />   
Kotlin~Adapter适配器模式
Hynson的学习笔记
03-26 1079
Adapter（Wrapper） Pattern，连接两个不兼容的接口，让接口不兼容的对象能够相互合作。
适配器模式（Adapter Pattern）
热门推荐
奶油芝士蘑菇汤的博客
03-08 2万+
一、定义 适配器模式（Adapter Pattern）：结构型模式之一，将一个类的接口转换成客户希望的另一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的哪些类可以一起工作。 二、UML类图 三、角色职责 目标角色（Target）：该角色定义把其他类转换为何种接口，也就是我们的期望接口。 源角色（Adaptee）：你想把谁转换成目标角色，这个“谁”就是源角色，它是已经存在的、运行良好的类或对象。 适配器角色（Adapter）：适配器模式的核心角色，其他两个角色都是已经存在的角色，而适配器
适配器模式（Adapter）
M_hhxc的博客
05-12 198
使原本不兼容的事物能够协同工作，且无需改变现有事物内部结构
Adapter 适配器模式
z55947810的博客
04-25 436
定义 适配器模式是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。 这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。 我们给手机充电时，电源线头头就叫电源适配器，作用就是把220V电压转换成手机充电时使用的电压，所以适配器很好理解。 优缺点 优点： 可以让任何两个没有关联的类一起运行。 提高了类的复用。 增加了类的透明度。 灵活性好 缺点： 过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被
Java设计模式之Adapter适配器模式
08-27
主要为大家详细介绍了Java设计模式之Adapter适配器模式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Python设计模式编程中Adapter适配器模式的使用实例
09-21
主要介绍了Python设计模式编程中Adapter适配器模式的使用实例,一般来说适配器模式可以细分为类适配器和对象适配器模式,需要的朋友可以参考下
Adapter适配器模式在JavaScript设计模式编程中的运用分析
10-22
适配器模式的作用是解决两个软件实体间的接口不兼容的问题,在JavaScript尤其是AJAX方面比较常用,接下来看一下对Adapter适配器模式在JavaScript设计模式编程中的运用分析
Proxy（代理模式）
我的专栏
08-17 5175
1、定义：                为其他对象提供一种代理以控制对这个对象的访问。 2、结构：        3、协作角色        proxy             （1）保存一个引用使得代理可以访问一个实体。             （2）提供一个与subject相同的接口，使得代理可以代替实体。               (3)  控制对实体的访问
buffer（缓冲区模式）
我的专栏
08-26 1381
1、定义：         将消息封装成一个对象，发送端将其存储到一个缓冲区中，接收端从缓冲区中取消息。 2、结构图：           3、协作角色：         略 4、适用性：       1、发送端和接收端不能同步        2、要对发送对象进行优化，排序等特殊处理 5、实例：       1、需求，发送任务和接受任务不能同步，        2、实现：
Strategy（策略模式）
我的专栏
08-20 633
1、定义     定义一系列的算法，把他们一个个封装起来，并且使他们可以相互替换。使得算法可以独立与使用它的客户而改变。 2、结构图 3、协作角色：           Strategy 定义所支持算法的接口。           ConcreteStrategy 具体算法           Context 用一个ConcreteStrategy对象来配置，维护一个对Strate
Command（命令模式）
我的专栏
08-24 622
1、定义：          将一个请求封装成一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。 2、结构图：               3、协作角色:        Command 声明执行操作的接口。        ConcreteCommand 将一个对象绑定与一个动作，调用接受者相关的操作，以实现Execute（）
Decorator（装饰模式）
我的专栏
08-21 570
1、定义：        动态的给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更灵活。 2、结构图：        3、协作角色     Component 定义一个对象的接口，可以给这些对象动态的增加职责。     ConcreteComponent  定义一个对象，可以给这些对象添加一些职责。     Decorator 维持一个Component对象的指针，
设计模式基础
我的专栏
08-16 553
1、设计模式的定义           建筑大师Christopher Alexander说：“每个设计模式描述在我们周围不断发生的问题，以及该问题的核心解决方案，这样，就可以重复使用该方案而不必做重复劳动”（“Each pattern describes a problem which occurs over and over again in our environment, and the
适配器模式2 外观模式
最新发布
05-31
适配器模式(Adapter Pattern)是一种结构型设计模式，它允许你将现有的类（即不兼容的类）转换为其他接口所期望的接口。适配器模式旨在使原本由于接口不兼容而不能一起工作的类可以一起工作[^1]。适配器模式通常用于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值