设计模式C++实现(二)结构型模式

最新推荐文章于 2023-07-10 18:53:58 发布
最新推荐文章于 2023-07-10 18:53:58 发布
阅读量229 收藏 1
点赞数 1
分类专栏： C/C++ 文章标签： C++ 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhwhg123/article/details/100045100
版权

目录

 

桥接模式

功能：

类图：

代码：

适配器模式

功能：

类图：

代码：

装饰者模式

功能：

类图：

代码：

组合模式

功能：

类图：

代码：

享元模式

功能：

类图：

代码：

外观模式

功能：

类图：

代码：

代理模式

功能：

类图：

代码：

桥接模式

功能：

Bridge 是设计模式中比较复杂和难理解的模式之一，也是 OO 开发与设计中经常会用到 的模式之一。使用组合（委托）的方式将抽象和实现彻底地解耦，这样的好处是抽象和实现 可以分别独立地变化，系统的耦合性也得到了很好的降低。

类图：

代码：

#include<iostream>

using namespace std;

class Soft
{
public:
	virtual void run()=0;
};
class SoftA:public Soft
{
public:
	void run()
	{
		cout<<"run softA"<<endl;
	}
};
class SoftB:public Soft
{
public:
	void run()
	{
		cout<<"run softB"<<endl;
	}
};

class PhoneClass
{
protected:
	Soft* soft;
public:
	void installSofr(Soft* s)
	{
		this->soft = s;
	}
	virtual void runSoft()=0;
};
class PhoneA:public PhoneClass
{
public:
	void runSoft()
	{
		cout<<"phonea"<<"->";
		soft->run();
	}
};
class PhoneB:public PhoneClass
{
public:
	void runSoft()
	{
		cout<<"phoneb"<<"->";
		soft->run();
	}
};


int main()
{
	Soft* softa = new SoftA();
	Soft* softb = new SoftB();
	PhoneClass* phonea = new PhoneA();
	PhoneClass* phoneb = new PhoneB();
	phonea->installSofr(softb);
	phonea->runSoft();
	phoneb->installSofr(softa);
	phoneb->runSoft();


	return 0;
}

适配器模式

功能：

我们在应用程序中已经设计好了接口， 与这个第三方提供的接口不一致，为了使得这些接口不兼容的类（不能在一起工作）可以在 一起工作了，Adapter 模式提供了将一个类（第三方库）的接口转化为客户（购买使用者） 希望的接口。

在上面生活中问题的解决方式也就正好对应了 Adapter 模式的两种类别：类模式和对象 模式。

类图：

代码：

以对象模式为例

#include<iostream>

using namespace std;

class Target
{
public:
	virtual void request()
	{
		cout<<"target request"<<endl;
	}
};

class Adaptee
{
public:
	void specificRuquest()
	{
		cout<<"Adaptee::specificRuquest"<<endl;
	}
} ;

class Adapter:public Target
{
private:
	Adaptee* adap;
public:
	Adapter(Adaptee* ad)
	{
		this->adap = ad;
	}
	void request()
	{
		this->adap->specificRuquest();
	}
};


int main()
{
	Adaptee* ad = new Adaptee();
	Target* t = new Adapter(ad);
	t->request();
	return 0;
}

装饰者模式

功能：

在 OO 设计和开发过程，可能会经常遇到以下的情况：我们需要为一个已经定义好的类 添加新的职责（操作），通常的情况我们会给定义一个新类继承自定义好的类，这样会带来 一个问题（将在本模式的讨论中给出）。通过继承的方式解决这样的情况还带来了系统的复 杂性，因为继承的深度会变得很深。

而 装饰者提供了一种给类增加职责的方法，不是通过继承实现的，而是通过组合。 有关这些内容在讨论中进一步阐述。

用于在原有的基础上进行动态扩展。

类图：

代码：

#include<iostream>

using namespace std;

class Component //对象接口
{
public:
	virtual void operation() = 0;
};
class ComponentSon1:public Component
{
public:
	void operation()
	{
		cout<<"operation Son1"<<endl;
	}
};

class Decorator:public Component
{
protected:
	Component* com;
public:
	Decorator(Component* c)
	{
		this->com = c;
	}
	void operation()
	{
		if(com)
			com->operation();
	}
};
class Decorator1:public Decorator
{
public:
	Decorator1(Component* c):Decorator(c){}
	void operation()
	{
		com->operation();
		this->addBehavior();
	}
	void addBehavior()
	{
		cout<<"Decorator1 addBehavior"<<endl;
	}
};

int main()
{
	Component* com1 = new ComponentSon1();
	com1->operation();
	Decorator* d1 = new Decorator1(com1);
	d1->operation();

	return 0;
}

组合模式

功能：

将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

类图：

代码：

#include<iostream>
#include<vector>
#include<string>

using namespace std;

class Component
{
protected:
	string name;
public:
	Component(string n)
	{
		this->name = n;
	}
	virtual void add(Component* c)=0;
	virtual void remove(Component* c)=0;
	virtual void display()=0;
};

class Composite:public Component
{
public:
	vector<Component*> vCom;
public:
	Composite(string n):Component(n){}
	void add(Component* c)
	{
		vCom.push_back(c);
	}
	void remove(Component* c)
	{
		vector<Component*>::iterator ite = vCom.begin();
		while(ite != vCom.end())
		{
			if(*ite == c)
			{
				vCom.erase(ite);
				break;
			}
			ite++;
		}
	}
	void display()
	{
		cout<<name<<endl;
		for(auto i:vCom)
		{
			i->display();
		}
		
	}
};

class Leaf:public Component
{
public:
	Leaf(string n):Component(n){};
	void add(Component* c)
	{
		cout<<"leaf can not add"<<endl;
	}
	void remove(Component* c)
	{
		cout<<"leaf can not remove"<<endl;
	}
	void display()
	{
		cout<<name<<endl;
	}
};

int main()
{
	Component* root = new Composite("root");
	Component* leafa = new Leaf("LeafA");
	Component* leafb = new Leaf("LeafB");
	root->add(leafa);
	root->add(leafb);
	Component* coma = new Composite("ComA");
	root->add(coma);
	Component* leafaa = new Leaf("LeafAA");
	Component* leafab = new Leaf("LeafAB");
	coma->add(leafaa);
	coma->add(leafab);
	Component* comac = new Composite("ComAC");
	coma->add(comac);
	Component* aca = new Leaf("LeafACA");
	comac->add(aca);
	root->display();
	cout<<endl;
	root->remove(coma);
	root->display();
	return 0;
}

享元模式

功能：

运用共享技术有效的支持大量细粒度的对象。

将 对象的状态分为“外部状态”和“内部状态”，将可以被共享（不会变化）的状态作为内部 状态存储在对象中，而外部对象（变化的）我们可以在适当的时候将 外部对象最为参数传递给对象。

外部状态也可以以参数的形式传递。

类图：

代码：

#include<iostream>
#include<string>
#include<vector>

using namespace std;

class FlyWeight
{
protected:
	string m_str;

public:
	FlyWeight(){}
	FlyWeight(string str):m_str(str){}
	string getObject()
	{
		return this->m_str;
	}
	virtual void operation()=0;
};

class SharedFlyWeight:public FlyWeight
{
public:
	SharedFlyWeight(string str):FlyWeight(str){}
	void operation()
	{
		cout<<"shared:"<<m_str<<endl;
	}
};

class UnShared:public FlyWeight
{
public:
	string unStr;
public:
	UnShared(string str)
	{
		unStr = str;
	}
	void operation()
	{
		cout<<"unshared:"<<unStr<<endl;
	}
};

class FlyWeightFactory
{
private:
	vector<FlyWeight*> vFly;
public:
	FlyWeight* getFlyWeight(string str)
	{
		vector<FlyWeight*>::iterator ite = vFly.begin();
		while(ite != vFly.end())
		{
			if((*ite)->getObject() == str)
			{
				(*ite)->operation();
				return *ite;
			}
			ite++;
		}
		FlyWeight* f = new SharedFlyWeight(str);
		f->operation();
		vFly.push_back(f);
		return f;
	}
	void addUnshared(FlyWeight* unshared)
	{
		unshared->operation();
	}
};

int main()
{
	FlyWeightFactory* fly = new FlyWeightFactory();
	fly->getFlyWeight("175");
	FlyWeight* un1 = new UnShared("whg");
	fly->addUnshared(un1);
	fly->getFlyWeight("175");
	FlyWeight* un2 = new UnShared("whc");
	fly->addUnshared(un2);

	return 0;
}

外观模式

功能：

为子系统中的一组接口提供一个一致的界面，使子系统更加容易使用。

类图：

代码：

#include<iostream>
using namespace std;

class SubSystem1
{
public:
	
	void operation()
	{
		cout<<"SubSystem1"<<endl;
	}
};
class SubSystem2
{
public:
	void operation()
	{
		cout<<"SubSystem2"<<endl;
	}

};

class Facade
{
private:
	SubSystem1* sub1;
	SubSystem2* sub2;
public:
	Facade()
	{
		sub1 = new SubSystem1();
		sub2 = new SubSystem2();
	}
	void operation()
	{
		sub1->operation();
		sub2->operation();
	}
	~Facade()
	{
		delete sub1;
		delete sub1;
	}
};

int main()
{
	Facade* f = new Facade();
	f->operation();
	delete f;

	return 0;
}

代理模式

功能：

为其他对象ti'gong 一种代理以控制对这个对象的访问。

类图：

代码：

#include<iostream>

using namespace std;

class Subject //代理和实体公共接口，这样才能使代理会干实体的活
{
public:
	virtual void request()=0;
	virtual ~Subject(){}
};

class RealSubject:public Subject //实体
{
public:
	void request()
	{
		cout<<"RealSubject"<<endl;
	}
};
class Proxy:public Subject //代理
{
private:
	Subject* m_sub;
public:
	Proxy(Subject* sub)
	{
		m_sub = sub;
	}
	void request()
	{
		m_sub->request();
	}
	~Proxy()
	{
		if(m_sub)
			delete m_sub;
		m_sub = 0;
	}
};

int main()
{
	Subject* sub = new RealSubject();
	Proxy* pro = new Proxy(sub);
	pro->request();

	return 0;
}
hhwhg123
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++设计模式-结构型模式-桥接模式
06-12
c++设计模式-结构型模式-桥接模式；qt工程，c++简单源码； 桥接（Bridge）模式的定义如下：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度...
动态生成结构体
qq_38072307的博客
01-24 1475
动态生成结构体（2）使用new #include&lt;iostream&gt; #include&lt;string&gt; using namespace std; typedef struct a { int x; int y; }; void main() { int num=10; a *al=new a[num]; for(int i=0;i&lt;num;i++) { ...
c语言动态生成结构体结构,C语言实现动态结构体数组
weixin_42615290的博客
05-19 3521
C语言实现动态结构体数组原因是因为以前使用C++来实现的，主要用VERCTOR C++标准库的失代器而不是纯C；C++是C语言的超集，除了包含C外，还有C++各种新语法，新库！不过虽然C++用起来简单，开发效率高，不过相对C语言来说运行速度慢，占用内存大。最烦得就是编译速度贼慢！以前小仙使用C++BUILDER 开发WINDOWS桌面应用，基本上编译需要5分钟时间。而最近编译MYSQL 8.0.2...
动态分配结构体空间并用指针进行操作
frueyang的博客
12-10 778
动态分配结构体空间并用指针进行操作 要求利用动态内存分配进行结构体指针的内存分配，然后设计函数，计算平均成绩，要求结构体指针作为函数参数，观察值的影响。 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Student // 定义结构体类型，并声明别名 { ch...
巧妙利用结构体解析协议数据
ApexYuan
01-13 1517
巧妙利用结构体解析协议数据 文章目录巧妙利用结构体解析协议数据预备知识1. 大小端2. 位域3. 结构体字节对齐4. 联合体实例一：根据电池BMS协议解析电池数据（小端模式）电池应答消息包含的电池数据1. 电池状态信息2. 电流值3. 电芯串数4. 电芯电压5. 循环次数6. 剩余电量7. 总容量8. 开关状态根据电池应答消息格式定义电池数据结构分析实例二：根据电池BMS协议解析电池数据（大端模式）电池应答消息包含的电池数据根据电池应答消息格式定义电池数据结构使用分析 预备知识 1. 大小端 STM32属于
共用体
03-27 5874
有时需要使几种不同类型的变量存放到同一段内存单元中。例如可以一个整形变量，一个字符型变量，一个实型变量放在同一地址开始的内存单元中。以上3个变量在内存单元中占的字节数不同，但是都从同一地址开始存放。也就是使用覆盖技术，几个变量互相覆盖。 共用体也是一种构造数据类型，它是将不同类型的变量存放在同一内存区域内。共用体也称为联合（union）。共用体的类型定义、变量定义及引用方式与
c++设计模式-结构型模式-适配器模式
06-12
c++设计模式-结构型模式-适配器模式，其他工程，c++源码。适配器模式（Adapter）的定义如下：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
c++设计模式-结构型模式-代理模式
06-12
c++设计模式-结构型模式-代理模式，qt工程，c++源码，简单示例
c++设计模式-结构型模式-组合模式
06-16
c++设计模式-结构型模式-组合模式；qt工程；c++简单源码； 组合（Composite Pattern）模式的定义：有时又叫作整体-部分（Part-Whole）模式，它是一种将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系...
c++设计模式-结构型模式-外观模式
06-13
c++设计模式-结构型模式-外观模式；qt工程；c++简单源码； 外观（Facade）模式又叫作门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，...
C/C++结构体序列化配置模板化
05-09
代码说明： http://blog.csdn.net/catxl313/article/details/25434275
结构体和数据结构--动态数据结构体-单向链表
ww1425408527的博客
07-10 747
第2部分是一个结构体指针，称为链表的指针域，用于存储其直接后继的节点信息，这里用next表示，next的值实际上就是下一个节点的地址，即next指向下一个节点，当前节点为末节点时，next的值设为空指针（NULL），表示链表的结束。（3）若在链表中间插入新节点，则将新节点的指针域指向下一节点（p->next = pr->next），且让前一节点的指针域指向新节点（pr->next = p）。注意：节点被删除后，指标是将它从链表中断开而已，它仍然占用内存，必须释放其所占的内存，否则将出现内存泄漏。
MFC 的CList，CPtrList，CObList，CStringList 的用法之CList
mfreesky的专栏
08-02 4899
CList 类 C++中实现通用数据结构在程序设计当中经常会出现使用同种数据结构的不同实例的情况。例如:在一个程序中可以使用多个队列、树、图等结构来组织数据。同种结构的不同实例,也许只在数据元素的类型或数量上略有差异,如果对每个实例都重新定义,则非常麻烦且容易出错。那么能否对同种类型数据结构仅定义一次呢?答案是肯定的,C++提供的类模板(Class Template)就可以实现该功能。一、类模
01-0007 关于C/C++读取文件，并建立指定结构
雯饰太一的博客
03-30 184
C/C++读取文件，并建立指定结构1. 问题2. 读取方案2.1 混合QT与C++的读取方式2.2 stringstream的读取方式2.3 C风格fscanf()的读取方式3. 思考&相关链接 1. 问题 有一系列的数据文件，以txt的形态存在，具体的格式如下： 123 44 12 124 45 67 23 45 67 ... 上述文件中，每行三个int类型的数据，以空格隔开，每行末尾是换行 现在，需要将其读入到内存中，并且存储于向量之中，向量的组织结构如下： //声明 std::vecto
40-C++-使用new创建动态结构
青木年华
06-15 8726
4.8.4使用new创建动态结构 在运行时创建数组优于在编译时创建数组，对于结构也是如此。需要在程序运行时为结构分配所需的空间，这也可以使用new运算符来完成。通过使用new,可以创建动态结构。同样，“动态”意味着内存是在运行时，而不是编译时分配的。由于类与结构非常相似，因此木节介绍的有关结构的技术也适用于类。 将new用于结构由两步组成:创建结构和访问其成员。要创建结构，需要同时使用结构类型和n...
创建结构体的三种方式及其使用
热门推荐
学习笔记
07-23 1万+
#include //创建结构体的第一种方式，推荐用这种 struct Student1{ int age; float score; char sex; }; //创建结构体的第二种方式 struct Student2{ int age; float score; char sex; }stu2; //创建结构体的第三种方式 struct { int age; flo
【C++】（十五）自定义数据类型——结构体
weixin_44378835的博客
10-24 1765
文章目录自定义数据类型——结构体1 结构体的定义与使用1.1 定义结构体类型1.2 结构体类型实例化1.3 结构体对象的内存形式1.4 结构体对象成员引用2 结构体与数组、指针、函数2.1 结构体与数组2.2 结构体与指针2.3 结构体与函数 自定义数据类型——结构体 1 结构体的定义与使用 数组是一种数据形式，其特点是多个相同类型的元素集合起来； 结构体是另一种重要的数据形式，特点是将不同类型的成员组合起来。 数组和结构体形成了两种风格迥异的聚合方式，通过他们及其相互 组合、嵌套的机制可以构造出复杂的、满
C++结构体的定义和创建
一季南凉的博客
08-05 2902
结构体的基本概念： 结构体属于用户自定义的数据类型，允许用户存储不同的数据类型 结构体的定义和使用 struct student{ string name; int age; int score; }; 1.struct 结构体名 {结构体成员列表}； 结构体创建变量的方式有三种： struct 结构体名 变量名 struct student s1; s1.name="张三"; s1.age=18; s1.score=100; struct 结构体名 变量名={成员1值，成员2值…} struct
c++解析xml文件到结构体
huangshuo0的博客
12-09 1173
XML文件是一种常见的用于存储数据的格式。在C++中，可以使用多种方法来解析XML文件。其中一种方法是使用C++的标准库中的和头文件中的流对象。例如，下面是一个示例代码，用于解析XML文件，并将其中的数据存储在C++结构体中：
c++实现适配器设计模式
最新发布
08-24
适配器设计模式是一种结构型设计模式，它用于将一个类的接口转换为客户端所期望的另一个接口。在C语言中，可以通过以下步骤来实现适配器设计模式： 1. 首先，定义目标接口（Target Interface），这是客户端期望的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值