设计模式（GOF&&C++）

最新推荐文章于 2022-04-09 18:24:56 发布
最新推荐文章于 2022-04-09 18:24:56 发布
阅读量374 收藏 3
点赞数 2
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanjia0609/article/details/107122873
版权

设计模式

1.单例模式

  • 饿汉模式（不管需不需要，初始化时直接创建实例）
class Singleton {
	//(1)构造函数私有化
private:
	Singleton(){
		m_singer = NULL;
	}
	//(2)提供全局访问点
public:
	static Singleton *GetInstance() {
		return m_singer;
	}

	static void FreeInstatce() {
		if (m_singer) {
			delete m_singer;
			m_singer = NULL;
		}
	}
	//(3)定义一个静态指针
private:
	static Singleton *m_singer;
};

//(4)创建实例
Singleton *Singleton::m_singer = new Singleton;

int main() {
	Singleton *s1 = Singleton::GetInstance();
	return 0;
}
  • 懒汉模式（等到需要时再创建）
  • 效率比较低
class Singleton {
	//(1)构造函数私有化
private:
	Singleton() {
		m_singer = NULL;
	}
	//(2)提供全局访问点
public:
	static Singleton *GetInstance() {
		if (!m_singer) {    //若未创建实例
			lock();         //防止并发访问
			if (!m_singer) {//二次判断
				m_singer = new Singleton;
			}
			unlock();
		}
		return m_singer;
	}
private:
	static Singleton *m_singer;
};

Singleton *m_signer = NULL;

2.简单工厂模式

创建一个工厂，根据输入条件的不同，产生不同的类，这些类具有相同的抽象类。
//(1)定义抽象类
class Fruit {
public:
	virtual void getFruit() = 0;
};

//(2)定义具体类
class Banana:public Fruit {
public:
	void getFruit() {
		cout << "Banana!" << endl;
	}
};

class Apple :public Fruit {
public:
	void getFruit() {
		cout << "Apple!" << endl;
	}
};

//(3)定义工厂
class Factory {
public:
	static Fruit *create(const char *name) {
		Fruit *tmp = NULL;

		if (strcmp(name, "banana") == 0)
			tmp = new Banana;
		else if (strcmp(name, "apple") == 0)
			tmp = new Apple;
		else
			return NULL;

		return tmp;
	}
};

int main() {
	Fruit *b = Factory::create("banana");
	if (!b)
		cout << "Creat b err!" << endl;
	b->getFruit();

	Fruit *a = Factory::create("apple");
	if (!a)
		cout << "Creat a err!" << endl;
	a->getFruit();

	return 0;
}

3.工厂模式

与简单工厂模式不同，核心工厂类作为一个抽象角色，负责具体工厂子类必须实现的接口。
class Fruit {
public:
	virtual void say() {
		cout << "fruit" << endl;
	}
};

class FruitFactory {
public:
	virtual Fruit *getFruit() {
		return new Fruit;
	}
};

class Banana :public Fruit {
public:
	virtual void say() {
		cout << "banana" << endl;
	}
};

class BananaFactory :public FruitFactory {
public:
	virtual Fruit *getFruit() {
		return new Banana;
	}
};

class Apple :public Fruit {
public:
	virtual void say() {
		cout << "apple" << endl;
	}
};

class AppleFactory :public FruitFactory {
public:
	virtual Fruit *getFruit() {
		return new Apple;
	}
};

int main() {
	Fruit *f = NULL;
	FruitFactory *ff = NULL;

	ff = new BananaFactory;
	f = ff->getFruit();
	f->say();

	ff = new AppleFactory;
	f = ff->getFruit();
	f->say();

	return 0;
}

4.抽象工厂模式

工厂模式只能生产一个产品，而抽象工厂模式可以生产一个产品组。
class Fruit {
public:
	virtual void say() {
		cout << "fruit" << endl;
	}
};

class FruitFactory {
public:
	virtual Fruit *getApple() {
		return new Fruit;
	}

	virtual Fruit *getBanana() {
		return new Fruit;
	}
};

class SouthBanana :public Fruit {
public:
	virtual void say() {
		cout << "south banana" << endl;
	}
};

class SouthApple :public Fruit {
public:
	virtual void say() {
		cout << "south apple" << endl;
	}
};

class NorthBanana :public Fruit {
public:
	virtual void say() {
		cout << "north banana" << endl;
	}
};

class NorthApple :public Fruit {
public:
	virtual void say() {
		cout << "north apple" << endl;
	}
};

class SouthFactory :public FruitFactory {
	virtual Fruit *getApple() {
		return new SouthApple;
	}

	virtual Fruit *getBanana() {
		return new SouthBanana;
	}
};

class NorthFactory :public FruitFactory {
	virtual Fruit *getApple() {
		return new NorthApple;
	}

	virtual Fruit *getBanana() {
		return new NorthBanana;
	}
};

int main() {
	Fruit *f = NULL;
	FruitFactory *ff = NULL;

	ff = new SouthFactory;
	f = ff->getApple();
	f->say();
	f = ff->getBanana();
	f->say();

	ff = new NorthFactory;
	f = ff->getApple();
	f->say();
	f = ff->getBanana();
	f->say();

	return 0;
}

5.建造者模式

一个对象的构建比较复杂，将一个对象的构建和对象的表示进行分离。
class House {
public:
	void setFloor(string floor)
	{
		this->m_floor = floor;
	}

	void setDoor(string door) {
		this->m_door = door;
	}

	void setWall(string wall) {
		this->m_wall = wall;
	}

	string getFloor() {
		return this->m_floor;
	}

	string getDoor() {
		return this->m_door;
	}

	string getWall() {
		return this->m_wall;
	}
private:
	string m_floor;
	string m_door;
	string m_wall;
};

class Builder {
public:
	virtual void makeFloor() = 0;
	virtual void makeDoor() = 0;
	virtual void makeWall() = 0;
	virtual House *getHouse() = 0;
};

class FlatBuild :public Builder {
public:
	FlatBuild() {
		this->m_house = new House;
	}

	virtual void makeFloor() {
		m_house->setFloor("Flat Floor");
	}

	virtual void makeDoor() {
		m_house->setDoor("Flat Door");
	}

	virtual void makeWall() {
		m_house->setWall("Flat Floor");
	}

	virtual House *getHouse() {
		return m_house;
	}

private:
	House * m_house;
};

class VillaBuild :public Builder {
public:
	VillaBuild() {
		this->m_house = new House;
	}

	virtual void makeFloor() {
		m_house->setFloor("Villa Floor");
	}

	virtual void makeDoor() {
		m_house->setDoor("Villa Door");
	}

	virtual void makeWall() {
		m_house->setWall("Villa Floor");
	}

	virtual House *getHouse() {
		return m_house;
	}

private:
	House * m_house;
};

class Director {
public:
	void construct(Builder *b)
	{
		b->makeFloor();
		b->makeDoor();
		b->makeWall();
	}
};

int main() {
	House *h = NULL;
	Builder *b = NULL;
	Director *d = NULL;
	d = new Director;

	b = new FlatBuild;
	d->construct(b);
	h = b->getHouse();
	cout << h->getDoor() <<endl ;
	cout << h->getFloor() << endl;
	cout << h->getWall() << endl;

	b = new VillaBuild;
	d->construct(b);
	h = b->getHouse();
	cout << h->getDoor() << endl;
	cout << h->getFloor() << endl;
	cout << h->getWall() << endl;


	return 0;
}

6.原型模式

一个复杂对象具有自我复制功能，统一一套接口。采用复制原型对象的方法来创建对象的实例。
class Person {
public:
	virtual Person *clone() = 0;
	virtual void say() = 0;
};

class CppProgrammer:public Person {
public:
	CppProgrammer() {
		this->m_name = "";
		this->m_age = 0;
		this->m_resume = NULL;
	}

	CppProgrammer(string name, int age) {
		this->m_name = name;
		this->m_age = age;
		this->m_resume = NULL;
	}

	~CppProgrammer() {
		if (this->m_resume)
		{
			delete this->m_resume;
			this->m_resume = NULL;
		}
	}

	virtual void say() {
		cout << this->m_name << " ," << this->m_age << " ," << this->m_resume << "!" << endl;
	}

	void setResume(const char *s) {
		this->m_resume = new char[strlen(s)+1];
		memcpy(this->m_resume, s, strlen(s)+1);
	}

	virtual Person *clone() {
		CppProgrammer *p = new CppProgrammer;
		*p = *this; //浅拷贝
		p->setResume(this->m_resume);//深拷贝

		return p;
	}
private:
	string m_name;
	int m_age;
	char *m_resume;
};

int main() {

	CppProgrammer *p1= new CppProgrammer("jack", 18);
	p1->setResume("I'm a Cpp programmer!");
	p1->say();
	
	Person *p2 = p1->clone();
	delete p1;
	p2->say();

	return 0;
}

7.代理模式

为其他对象，提供一种代理，以控制对对象的访问。
//01.定义抽象接口
class Interface {
public:
	virtual void Request() = 0;
};

//02.真实对象
class RealSubject : public Interface{
public:
	virtual void Request() {
		cout << "真实的请求" << endl;
	}
};

//0.3代理
class ProxySubject :public Interface {
public:
	virtual void Request() {
		this->m_realSubject = new RealSubject;
		this->m_realSubject->Request();
		delete this->m_realSubject;
		this->m_realSubject = NULL;
	}
private:
	RealSubject *m_realSubject;
};

int main() {
	ProxySubject *ps = new ProxySubject;
	ps->Request();

	return 0;
}

8.装饰模式

动态的给一个对象添加一些额外的职责。
class Car {
public:
	virtual void show() = 0;
};

class RunCar : public Car{
public:
	void run() {
		cout << "可以跑" << endl;
	}

	virtual void show() {
		run();
	}
};

class SwimCar : public Car {
public:
	SwimCar(Car *car)
	{
		this->m_car = car;
	}

	void swim() {
		cout << "可以游" << endl;
	}

	virtual void show() {
		m_car->show();
		swim();
	}
private:
	Car *m_car;
};

class FlyCar : public Car {
public:
	FlyCar(Car *car)
	{
		this->m_car = car;
	}

	void fly() {
		cout << "可以飞" << endl;
	}

	virtual void show() {
		m_car->show();
		fly();
	}
private:
	Car *m_car;
};

int main() {
	Car *run_car = new RunCar;
	run_car->show();
	cout << endl;

	SwimCar *swim_car = new SwimCar(run_car);
	swim_car->show();
	cout << endl;

	FlyCar *fly_car = new FlyCar(swim_car);
	fly_car->show();

	delete fly_car;
	delete swim_car;
	delete run_car;

	return 0;
}

9.适配器模式

将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的那些类，一起工作。
class Current18v {
public:
	void use18vCurrent() {
		cout<<"使用18v的交流电"<<endl;
	}
};

class Current220v {
public:
	void use220vCurrent() {
		cout << "使用220v的交流电" << endl;
	}
};

class Adapater :public Current18v {
public:
	Adapater(Current220v *p_220v)
	{
		this->m_220v = p_220v;
	}

	void use18vCurrent() {
		cout << "Adapater中使用电流" << endl;
		this->m_220v->use220vCurrent();
	}
private:
	Current220v * m_220v;
};

int main() {
	Current220v *p_220v = new Current220v;
	Adapater *p_adapater = new Adapater(p_220v);
	p_adapater->use18vCurrent();

	delete p_adapater;
	delete p_220v;

	return 0;
}

10.组合模式

单个对象和组合对象的使用具有一致性，将单个对象组合成树形结构以表示“部分–整体”
class IFile {
public:
	virtual void display() = 0;
	virtual int add(IFile *ifile) = 0;
	virtual int remove(IFile *ifile) = 0;
	virtual list<IFile *>  *getChild() = 0;
};

class File : public IFile {
public:
	File(string name) {
		this->m_name = name;
		m_list = NULL;
	}

	~File() {
		if(m_list != NULL)
		    delete m_list;
	}

	virtual void display() {
		cout << m_name << endl;
	}

	virtual int add(IFile *ifile) {
		return -1;
	}
	virtual int remove(IFile *ifile) {
		return -1;
	}
	virtual list<IFile *>  *getChild() {
		return NULL;
	}
private:
	list<IFile *> *m_list;
	string m_name;
};

class Folder : public IFile {
public:
	Folder(string name) {
		this->m_name = name;
		m_list = new list<IFile *>;
	}

	~Folder() {
		if(m_list != NULL)
		    delete m_list;
	}

	virtual void display() {
		cout << m_name << endl;
	}

	virtual int add(IFile *ifile) {
		m_list->push_back(ifile);
		return 0;
	}
	virtual int remove(IFile *ifile) {
		m_list->remove(ifile);
		return 0;
	}
	virtual list<IFile *>  *getChild() {
		return m_list;
	}
private:
	list<IFile *> *m_list;
	string m_name;
};

void show_tree(IFile *ifile, int level) {
	list<IFile *> *l = NULL;

	for (int i = 0; i < level; i++)
		printf("\t");

	ifile->display();

	l = ifile->getChild();

	if (l) {
		++level;
		for (list<IFile *>::const_iterator it = l->begin(); it != l->end(); it++) {
			if ((*it)->getChild() == NULL)
			{
				for (int i = 0; i < level; i++)
					printf("\t");

				(*it)->display();
			}
			else {
				show_tree((*it), level);
			}
			
		}
	}
}

int main() {
	Folder *root = new Folder("root");

	Folder *d1 = new Folder("dir1");
	File *f1 = new File("f1");

	Folder *d2 = new Folder("dir2");
	File *f2 = new File("f2");

	root->add(d1);
	root->add(d2);

	d1->add(f1);
	d2->add(f2);

	show_tree(root, 0);

	delete f2;
	delete d2;
	delete f1;
	delete d1;
	delete root;

	return 0;
}

11.桥接模式

Slowly__Run
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++设计模式GoF23
10-28
懂了设计模式，你就懂了面向对象分析和设计（OOA/D）的精要。反之好像也可能成 立。道可道，非常道。道不远人，设计模式亦然如此。 一直想把自己的学习经验以及在项目中的应用经历拿出来和大家共享，却总是下不了这 ...
GOF23种设计模式C++版本
小胖七少爷的博客
07-19 738
GOF设计模式，C++实现
【C/C++ 设计模式】GOF-23种设计模式
qq_43142509的博客
11-07 594
GOF设计模式 说到设计模式，可能让人感到困惑。这里我引用 Christopher Alexander 大师的一句话：“每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次又一次地使用该方案而不必做重复劳动”。 在整个软件设计中，让人头大，让人感到困难的根本原因就是变化，而如何去解决各种变化带来的复杂性就是一个好的程序急需解决的。 学习设计模式，目的就是能够设计出更加优美，好维护，可复用，可拓展的优秀代码。利用复用来抵御变化。 COF-23 模式分类 从目地上来看：
C++ 设计模式之建造者模式
ACERROR
10-12 228
在软件工程中，设计模式（Design Pattern）是对软件设计普遍存在（反复出现）的各种问题，锁提出的解决防范。根据模式的目的来划分的话，GoF（Gang of Four） 设计模式可以分为以下三种类型： 1.创建型模式：用来描述“如何创建对象”，它的主要特点是“将对象的创建和使用分离”。包括单例、原型、工厂方法、抽象工厂和建造者5种模式。 2.结构型模式：用来描述如何将类或对象按照某种布局组成更大的结构。包括代理、适配器、侨接、装饰、外观、享元和组合7种模式。 3.行为型模式：用来识别对象之间的常用
GoF设计模式——工厂模式(C++实现)
weixin_44901043的博客
04-09 1143
文章目录🌳概念🌳 简单工厂模式🌳 工厂方法模式🌳 抽象工厂模式 🌳概念 为了提高内聚(Cohesion)和松耦合(Coupling),我们经常会抽象出一些类的公共 接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子 类实现,达到了多态的目的。 工厂模式属于创建型模式，它提供了一种创建对象的最佳方式。通过定义创建对象的接口，封装了对象的创建；使得类的实例化工作延迟到了子类中。 工厂模式的实现方式可分为简单工厂模式、工厂方法模式、抽象工厂模式。 🌳 简单工厂模式 🍞具体的情形：一个
c++设计模式gof
dowhathowtodo
08-03 184
摘自原文:http://dxwang.blog.51cto.com/384651/141588 设计模式分为 (1)创建者模式 1、工厂模式 （1）定义创建对象的接口， 封装了对象的创建 (2)将具体类的工作延迟到子类中实现 2、抽象工厂模式 关键在于将创建一组对象的封装到一组创建对象的类中 3、单例模式 4、建造者模式 Builder 模式要解决的也正是这样的问...
设计模式精解- GoF 23种设计模式解析附C++实现源码
10-24
设计模式精解- GoF 23种设计模式解析附C++实现源码 懂了设计模式，你就懂了面向对象分析和设计（OOA/D）的精要。反之好像也可能成立。道可道，非常道。道不远人，设计模式亦然如此。 一直想把自己的学习经验以及在...
设计模式精解-GoF-23种设计模式解析--附C++源代码
02-18
这些模式是由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides四位大师，通常被称为GoF（Gang of Four），在他们的经典著作《设计模式：可复用面向对象软件的基础》中提出的。这本书详细阐述了23种设计...
<<设计模式>>GOF,C++实例源码
04-27
设计模式>>GOF,C++实例源码 This is my implementation of the Design Patterns from the book 'Design Patterns: Elements of Reusable Object-Oriented Software' Erich Gamma, Richard Helm, Ralph Johnson, ...
设计模式精解GoF 23 种设计模式解析附 C++实现源码,例子非常好
11-04
设计模式C++ 实现 懂了设计模式，你就懂了面向对象分析和设计（OOA/D）的精要。反之好像也可能成立。道可道，非常道。道不远人，设计模式亦然如此。 可以作为入门教程
GoF 23种设计模式模式解析附C++实现源码
10-25
GoF 23种设计模式模式解析附C++实现源码
GoF 23 种设计模式解析附 C++实现源码
12-08
GoF 23 种设计模式解析附 C++实现源码pdf电子书
C++设计模式（GoF 23种设计模式解析附C++实现源码）
05-12
GoF 23种设计模式解析附C++实现源码，作者的一些编程经验
设计模式精解－GoF23种设计模式解析(附C++实现源码).pdf
11-09
设计模式精解－GoF23种设计模式解析(附C++实现源码)
笔记--设计模式精解c++－GoF 23 种设计模式解析
helonSY欢迎您的到来！
08-19 913
出处：http://dxwang.blog.51cto.com/384651/141588  0  引言 0.1 设计模式解析（总序） 0.2 设计模式解析后记 0.3  与作者联系 1  创建型模式 1.1 Factory模式  1）为了提高内聚（Cohes
用StartUML生成GoF设计模式类图与代码(c++)
永久指针
11-18 8864
先介绍一下startUML StarUML（http://www.staruml.com）的前身是Plastic，从1996年开始开发。1998年开始，Plastic转变为UML建模工具。2005年改名为StarUML，最新版本StarUML 5.0已经是一款功能全面的产品，支持UML2.0，支持MDA，Java、C++、C#转换，MS-Office集成，XMI等。
C++C++ 编写GoFGoF设计模式里Lexi样例
06-28 867
C++C++ 编写GoFGoF设计模式里Lexi样例 C++C++ 编写GoFGoF设计模式里Lexi样例 C++C++ 编写GoFGoF设计模式里Lexi样例 C++C++ 编写GoFGoF设计模式里Lexi样例 C++C++ 编写GoFGoF设计模式里Lexi样例 C++C++ 编写GoFGoF设计模式里Lexi样例C++C++ 编写GoFGoF设计模式里Lexi样例 C++C++ 编写GoF
23种设计模式(C++).pdf
最新发布
02-19
"《23种设计模式(C++)》是一本详细介绍GoF23种设计模式的书籍，书中结合C++实现源码进行解析，旨在帮助读者深入理解和应用设计模式。" 设计模式是软件工程中经过长期实践提炼出的通用解决方案，它们针对常见的设计...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值