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

最新推荐文章于 2022-10-06 17:30:41 发布
最新推荐文章于 2022-10-06 17:30:41 发布
阅读量272 收藏 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
关注
专栏目录
c++：结构型模式
xutong98的博客
08-15 657
继上篇，这篇讲述结构型模式。 结构型模式包括： 1、代理模式： （1）Proxy模式又叫做代理模式，是构造型的设计模式之一，它可以为其他对象提供一种代理（Proxy）以控制对这个对象的访            问。所谓代理，是指具有与代理元（被代理的对象）具有相同的接口的类，客户端必须通过代理与被代理的目标类交互，而           代理一般在交互的过程中（交互前后），进行某些特别的处理...
C++结构体的定义和创建
一季南凉的博客
08-05 2947
结构体的基本概念： 结构体属于用户自定义的数据类型，允许用户存储不同的数据类型 结构体的定义和使用 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
4.C++设计模式-结构型模型
weixin_42636062的博客
08-27 1705
4.C++设计模式-结构型模型 让类和类进行组合，获得更大的结构。 4.1 代理模式 4.1.1 代理模式的理论 代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 举例： 比如这里面服务器B的test可能还没写好，A访问不了，先访问代理类，写好了代替再代替访问 4.1.2 代理模式的案例 传统方法局限：是个人都能调用 #include <iostream> usin
设计模式C++ 笔记二 结构型模式
moonboat0331的专栏
09-26 588
1、Bridge模式 用户需求发生变化，要两个算法实现功能，往常状态需要多添加一个类。Bridge将系统分成两个相对独立的部分，抽象部分和实现部分。抽象部分根据参数，运行时动态决定采用哪个子类的函数。这样再加入一个函数实现时，只需要修改实现部分，继承出一个子类，不需要修改抽象部分。 //--------------Abstraction.h -----------------
C/C++设计模式之结构型设计模式
Lion_Long的博客
10-06 722
单例模式、工厂模式、抽象工厂模式、责任链模式、组合模式、装饰器模式是比较常用的结构型设计模式。
C++ 设计模式 -- 结构型模式
深入浅出讲透复杂深奥的问题
05-21 369
结构型模式(Structural Pattern)：描述如何将类或者对象结合在一起形成更大的结构，就像搭积木，可以通过简单积木的组合形成复杂的、功能更为强大的结构。 类结构型模式 关心类的组合，由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承关系和实现关系。 对象结构型模式 关心类与对象的组合，根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系，因此大部分结构型模式都是对象结构型模式。 ...
c++设计模式-结构型模式-代理模式
06-12
代理模式是一种在面向对象设计中广泛应用的结构型设计模式，它提供了一种对目标对象进行间接访问的方式，使得客户端可以通过代理对象与真实对象进行交互，而无需直接接触真实对象。这样做的好处包括增加灵活性、控制...
c++设计模式-结构型模式-组合模式
06-16
c++设计模式-结构型模式-组合模式；qt工程；c++简单源码； 组合（Composite Pattern）模式的定义：有时又叫作整体-部分（Part-Whole）模式，它是一种将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系...
c++设计模式-结构型模式-桥接模式
06-12
c++设计模式-结构型模式-桥接模式；qt工程，c++简单源码； 桥接（Bridge）模式的定义如下：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度...
c++设计模式-结构型模式-适配器模式
06-12
c++设计模式-结构型模式-适配器模式，其他工程，c++源码。适配器模式（Adapter）的定义如下：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
c++设计模式-结构型模式-装饰器模式
06-12
c++设计模式-结构型模式-装饰器模式；QT工程；c++简单源码； 装饰器（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
C/C++结构体序列化配置模板化
05-09
代码说明： http://blog.csdn.net/catxl313/article/details/25434275
C++设计模式系列之二结构型模式
F_r_e_e_x的专栏
06-24 2261
1.Adapter模式 Adapter.hpp: #ifndef _ADAPTER_HPP #define _ADAPTER_HPP //第三方库 namespace ThirdPartyNameSpace { class ThirdPartyClass { public: ThirdPartyClass(){} ~ThirdPartyClass(){}
根据配置文件初始分结构体 —— Linux 编程
u011285208的博客
12-17 319
static int read_conf_init_info(char * file_path, myStruct *attr) { int value = 0; char buf[256] = {0}; char *buf_ptr = NULL; char *value_ptr = NULL; char *cur_ptr = NULL; FILE *fp = NULL; ...
01-0007 关于C/C++读取文件，并建立指定结构
雯饰太一的博客
03-30 264
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
【C++】（十五）自定义数据类型——结构体
weixin_44378835的博客
10-24 1932
文章目录自定义数据类型——结构体1 结构体的定义与使用1.1 定义结构体类型1.2 结构体类型实例化1.3 结构体对象的内存形式1.4 结构体对象成员引用2 结构体与数组、指针、函数2.1 结构体与数组2.2 结构体与指针2.3 结构体与函数 自定义数据类型——结构体 1 结构体的定义与使用 数组是一种数据形式，其特点是多个相同类型的元素集合起来； 结构体是另一种重要的数据形式，特点是将不同类型的成员组合起来。 数组和结构体形成了两种风格迥异的聚合方式，通过他们及其相互 组合、嵌套的机制可以构造出复杂的、满
创建结构体的三种方式及其使用
热门推荐
学习笔记
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
MFC 的CList，CPtrList，CObList，CStringList 的用法之CList
mfreesky的专栏
08-02 4984
CList 类 C++中实现通用数据结构在程序设计当中经常会出现使用同种数据结构的不同实例的情况。例如:在一个程序中可以使用多个队列、树、图等结构来组织数据。同种结构的不同实例,也许只在数据元素的类型或数量上略有差异,如果对每个实例都重新定义,则非常麻烦且容易出错。那么能否对同种类型数据结构仅定义一次呢?答案是肯定的,C++提供的类模板(Class Template)就可以实现该功能。一、类模
动态生成结构体
qq_38072307的博客
01-24 1528
动态生成结构体（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++) { ...
GoF23种设计模式C++实现解析
“设计模式c++版，GoF23种设计模式解析，附带C++实现源码。” 本文将深入探讨设计模式的概念及其在C++编程语言中的应用。设计模式是软件工程中的一种最佳实践，它代表了在特定场景下解决常见问题的经验总结。在C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值