设计模式总结（一）

已于 2022-07-23 13:55:36 修改
阅读量417 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式
于 2022-07-18 23:39:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53492721/article/details/125783006
版权

面对对象中有哪些设计原则

在这里插入图片描述

开闭原则

在这里插入图片描述

里氏替换原则

在这里插入图片描述

迪米特原则

在这里插入图片描述

依赖导致原则在这里插入图片描述

** 举例解释**
在这里插入图片描述

自动驾驶系统公司是高层，汽车生产厂商为低层，它们不应该互相依赖，一方变动另一方也会跟着变动；而应该抽象一个自动驾驶行业标准，高层和低层都依赖它；这样以来就解耦了两方的变动；自动驾驶系统、汽车生产厂商都是具体实现，它们应该都依赖自动驾驶行业标准（抽象）。

多线程环境下单例模式

在这里插入图片描述
单例单线程模式

  • 保证一个类仅有一个实例：使用静态成员变量形式来实现。
  • 提供该实例的全局访问点：使用静态的成员函数来实现。
  • 保证申请在堆区的Singleton()能够被释合理的释放掉：使用c++中的库函数atextit()，atexit函数详解参考。并需手动实现析构函数。
  • 为了实现只能通过GetInstance()函数来实现对象的创建需要对外屏蔽构造函数、赋值操作、拷贝构造函数。
  • 静态成员函数只能访问静态成员变量和静态成员函数。
  • 静态成员函数没有this指针，不能调用成员函数，可参考static、const关键字。
//Singleton
#include <iostream>

class Singleton {
public:
	static Singleton* GetInstance() {
		if (_instance == nullptr) {
			_instance = new Singleton();
			std::atexit(Destructor);  //登记函数  
		}
		return _instance;
	}
private:
	static void Destructor() {  //实现析构
		if (_instance != nullptr) {
			delete _instance;
			_instance = nullptr;
		}
	}
	Singleton() {};
	~Singleton() {};  
	Singleton(const Singleton &clone) {};  //拷贝构造函数
	Singleton &operator= (const Singleton &) {};  //赋值操作
	static Singleton *_instance;  //一个类只有一个实例
};

Singleton* Singleton::_instance = nullptr;  //静态变量，类内声明类外初始化

多线程环境下单例模式—只加锁

  • 加锁只保证了临界资源只有一个线程访问。
//Singleton_thread 加锁
#include <iostream>
#include <mutex>

class Singleton {
public:
	static Singleton* GetInstance() {
		//std::lock_guard<std::mutex> lock(_mutex);  //该位置锁的力度过大
		if (_instance == nullptr) {  //第一次_instance没有值
			std::lock_guard<std::mutex> lock(_mutex);
			if (_instance == nullptr) {  //其他情况下_instance有值
				_instance = new Singleton();  //多线程环境下编译器和CPU会对程序进行优化
				std::atexit(Destructor);
			} 
		}
		return _instance;
	}
private:
	static void Destructor() {  //实现析构
		if (_instance != nullptr) {
			delete _instance;
			_instance = nullptr;
		}
	}
	Singleton() {};
	~Singleton() {};  
	Singleton(const Singleton &clone) {};  //拷贝构造函数
	Singleton &operator= (const Singleton &) {};  //赋值操作
	static Singleton *_instance;
	static std::mutex _mutex;
};

Singleton* Singleton::_instance = nullptr;  //静态变量，类内声明类外初始化
std::mutex Singleton::_mutex;

多线程环境下单例模式—加锁+原子操作

  • 多线程环境下编译器会对程序进行优化，导致指令执行顺序发生变化。
  • new 操作符执行了哪些操作：
    1） 分配内存；
    2）调用构造函数 （比较耗时）；
    3）返回指针，赋值运算符。
    编译器优化后执行顺序可能为：1 3 2。就会出现内存还没有进行构造就进行了返回。即_instance 不为空，但是_instaned没有经过构造函数初始化其内存，当使用到的时候就会出现错误。利用原子变量来避免这个现象。
//Singleton_atomic
#include <iostream>
#include <mutex>
#include <atomic>

class Singleton {
public:

	static Singleton* GetInstance() {
		Singleton* tmp = _instance.load(std::memory_order_relaxed);  //保证tmp原子性
		std::atomic_thread_fence(std::memory_order_acquire);  //内存屏障，不让tmp优化到下面
		//std::lock_guard<std::mutex> lock(_mutex);  //该位置锁的力度过大
		if (tmp == nullptr) {  //第一次_instance没有值
			std::lock_guard<std::mutex> lock(_mutex);
			tmp = _instance.load(std::memory_order_relaxed);

			if (tmp == nullptr) {  //其他情况下_instance有值
				tmp = new Singleton();  //多线程环境下编译器和CPU会对程序进行优化
				std::atomic_thread_fence(std::memory_order_release);  //不让store优化到上面去
				_instance.store(tmp, std::memory_order_relaxed);  //将tmp写回原子变量_instance中
				std::atexit(Destructor);
			} 
		}
		return tmp;
	}
private:
	static void Destructor() {  //实现析构
		Singleton* tmp = _instance.load(std::memory_order_relaxed);
		if (tmp != nullptr) {
			delete _instance;
			tmp = nullptr;
			_instance.store(tmp, std::memory_order_relaxed);
		}
	}
	Singleton() {};
	~Singleton() {};  
	Singleton(const Singleton &clone) {};  //拷贝构造函数
	Singleton &operator= (const Singleton &) {};  //赋值操作
	static std::atomic<Singleton*> _instance;
	static std::mutex _mutex;
};

std::atomic<Singleton*> Singleton::_instance;  //静态变量，类内声明类外初始化
std::mutex Singleton::_mutex;

工厂模式

在这里插入图片描述
工厂模式

// 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv

//factory
#include <string>
// 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv
class IExport {
public:
    virtual bool Export(const std::string &data) = 0;
    virtual ~IExport(){}
};

class ExportXml : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportJson : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportTxt : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportCSV : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class IExportFactory {
public:
    IExportFactory() {
        _export = nullptr;
    }
    virtual ~IExportFactory() {
        if (_export) {
            delete _export;
            _export = nullptr;
        }
    }
    bool Export(const std::string &data) {
        if (_export == nullptr) {
            _export = NewExport();
        }
        return _export->Export(data);
    }
protected:
    virtual IExport * NewExport(/* ... */) = 0;
private:
    IExport* _export;
};

class ExportXmlFactory : public IExportFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportXml();
        // 可能之后有什么操作
        return temp;
    }
};
class ExportJsonFactory : public IExportFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportJson;
        // 可能之后有什么操作
        return temp;
    }
};
class ExportTxtFactory : public IExportFactory {
protected:
    IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportTxt;
        // 可能之后有什么操作
        return temp;
    }
};

class ExportCSVFactory : public IExportFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportCSV;
        // 可能之后有什么操作
        return temp;
    }
};

int main () {
    IExportFactory *factory = new ExportTxtFactory();
    factory->Export("hello world");
    return 0;
}

抽象工厂

导出功能（IExport ）、导入功能（IImport），同一个格式的导入和导出是相关联的，我们通过一个接口去封装这个关联性，这里用IDataApiFactory来实现。

#include <string>
// 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv
class IExport {
public:
    virtual bool Export(const std::string &data) = 0;
    virtual ~IExport(){}
};

class ExportXml : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportJson : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportTxt : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class ExportCSV : public IExport {
public:
    virtual bool Export(const std::string &data) {
        return true;
    }
};

class IImport {
public:
    virtual bool Import(const std::string &data) = 0;
    virtual ~IImport(){}
};

class ImportXml : public IImport {
public:
    virtual bool Import(const std::string &data) {
        return true;
    }
};

class ImportJson : public IImport {
public:
    virtual bool Import(const std::string &data) {
        return true;
    }
};

class ImportTxt : public IImport {
public:
    virtual bool Import(const std::string &data) {
        return true;
    }
};

class ImportCSV : public IImport {
public:
    virtual bool Import(const std::string &data) {
        // ....
        return true;
    }
};

class IDataApiFactory {
public:
    IDataApiFactory() {
        _export = nullptr;
        _import = nullptr;
    }
    virtual ~IDataApiFactory() {
        if (_export) {
            delete _export;
            _export = nullptr;
        }
        if (_import) {
            delete _import;
            _import = nullptr;
        }
    }
    bool Export(const std::string &data) {
        if (_export == nullptr) {
            _export = NewExport();
        }
        return _export->Export(data);
    }
    bool Import(const std::string &data) {
        if (_import == nullptr) {
            _import = NewImport();
        }
        return _import->Import(data);
    }
protected:
    virtual IExport * NewExport(/* ... */) = 0;
    virtual IImport * NewImport(/* ... */) = 0;
private:
    IExport *_export;
    IImport *_import;
};

class XmlApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportXml;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportXml;
        // 可能之后有什么操作
        return temp;
    }
};

class JsonApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportJson;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportJson;
        // 可能之后有什么操作
        return temp;
    }
};
class TxtApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportTxt;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportTxt;
        // 可能之后有什么操作
        return temp;
    }
};

class CSVApiFactory : public IDataApiFactory {
protected:
    virtual IExport * NewExport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IExport * temp = new ExportCSV;
        // 可能之后有什么操作
        return temp;
    }
    virtual IImport * NewImport(/* ... */) {
        // 可能有其它操作，或者许多参数
        IImport * temp = new ImportCSV;
        // 可能之后有什么操作
        return temp;
    }
};

int main () {
    IDataApiFactory *factory = new CSVApiFactory();
    factory->Import("hello world");
    factory->Export("hello world");
    return 0;
}

直通通道：设计模式总结（二）

充电站
推荐一个零声学院免费公开课程，个人觉得老师讲得不错，分享给大家：Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等技术内容，立即学习

想当开心果哦
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
23种设计模式知识总结
03-18
在给定的“23种设计模式知识总结”中，我们涵盖了多种模式，每一种都有其独特的应用场景和优势。以下是这些设计模式的详细介绍： 1. **单例模式**：保证一个类只有一个实例，并提供一个全局访问点。它常用于控制...
设计模式总结
04-03
设计模式总结 设计模式是软件设计中一种常见的解决方案，它们可以帮助开发者写出更加灵活、可维护、可扩展的代码。设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。 创建型模式 创建型模式关心对象...
Java常见设计模式总结
张维鹏的博客
09-18 18万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
设计模式23模式介绍
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
Java中23种设计模式
呜呜老司机的博客家园
10-10 7万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
23种设计模式总结
lgxzzz的博客
05-25 7万+
一、什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛
设计模式期末总结
Thomas_cannon的博客
06-09 3689
设计模式期末总计
软件设计模式学习总结
Aatroy的博客
11-27 9284
软件设计模式的个人理解软件设计模式的简单分类面向对象的设计的7项原则简介创建型模式 软件设计模式的简单分类 GoF（Gang of Four）的 23 种设计模式： 创建型模式：单原工抽建 结构型模式：代适桥装，外享组 行为型模式：模策命，取状观，中迭访备解 面向对象的设计的7项原则简介 软件开发中，程序员要尽量根据以下7条原则来开发程序，从而提高软件的开发效率、节约软件开发成本和维护成本。 开闭原则 里氏替换原则 依赖倒置原则 单一职责原则 接口隔离原则 迪米特法则 合成复用原则 创建
常见的23种设计模式总结
秃头的博客
10-20 3465
创建型模式：单例模式、建造者模式、工厂模式、原型模式。 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式、过滤器模式。 行为型模式：模版模式(模版方法模式)、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式、访问者模式。
Java设计模式学习总结
Java技术江湖
07-08 5656
设计模式 创建型模式 创建型模式 创建型模式的作用就是创建对象，说到创建一个对象，最熟悉的就是 new 一个对象，然后 set 相关属性。但是，在很多场景下，我们需要给客户端提供更加友好的创建对象的方式，尤其是那种我们定义了类，但是需要提供给其他开发者用的时候。 单例 单例模式保证全局的单例类只有一个实例，这样的话使用的时候直接获取即可，比如数据库的一个连接，Spring里的be...
常用设计模式总结
热门推荐
yjclsx的博客
07-31 43万+
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结，是可复用面向对象软件的基础。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中...
Java设计模式总结
波波烤鸭的博客
04-18 4920
什么是设计模式   设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。通过对这些设计模式的合理使用能够是我们的系统更加的健壮。 六大设计原则 设计原则 简单说明 单一职责 一个类只负责一项职责 里氏替换原则 子类可以扩展父类的功能，但不能改变父类原有的功能 依赖倒置原则 要依赖于抽象，不要依赖于具体，核心思想是面向接...
Spring 设计模式总结1
08-04
Spring设计模式总结 在软件开发中，设计模式是解决常见问题的经验总结，它们为程序员提供了在特定场景下设计高效、可维护代码的蓝图。在Spring框架中，许多设计模式被广泛应用，以提升系统的灵活性和可扩展性。以下...
设计模式总结(2)
02-25
本文是设计模式总结的第二篇：主要详细讲解了行为型设计模式，希望对大家有所帮助。意图使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，...
设计模式之工厂模式总结
12-21
编辑Java笔记");}}增加Python笔记public ...设计模式是软件开发中的宝贵经验总结，工厂模式作为其中的一员，可以帮助我们编写更加灵活、可维护的代码。理解并熟练运用工厂模式，能够提升软件设计的质量和可扩展性。
基于STM32F103的FreeRTOS系列（一）·单片机设计模式介绍·裸机程序的设计模式
时光の尘的博客
07-22 1258
裸机程序的设计模式可以分为：轮询、前后台、定时器驱动、基于状态机。：周期性地查询各个模块或函数的状态，适用于简单且响应时间要求不高的系统，但无法有效解决复杂函数之间的相互影响问题。：通过将关键任务放在前台处理，而非关键任务放在后台，以确保关键任务的优先执行。这种方式对优先级管理有效，但复杂函数之间的相互影响仍可能存在。：通过定时器周期性地触发任务执行，适合需要定期执行任务的场景，但不能解决函数间相互影响的问题。：将系统的各种状态和状态转移定义清晰，通过状态切换来控制系统行为。
设计模式-单例模式
最新发布
weixin_51722520的博客
07-27 182
单例设计模式
C# 设计模式分类
語衣的个人博客
07-23 1013
创建型模式主要关注对象的创建过程，包括如何实例化对象，并隐藏实例化的细节。结构型模式主要关注类和对象的组合，以形成更大的结构。行为型模式主要关注对象之间的通信和职责分配。
js 优雅的实现模板方法设计模式
qq_43985303的博客
07-24 359
在JavaScript中，优雅地实现模板方法设计模式通常意味着我们要遵循一些最佳实践，如清晰地定义算法的骨架（模板方法），并确保子类能够灵活地扩展或修改这些算法中的特定步骤。此外，由于JavaScript的类和继承是基于原型的，因此这种实现方式也充分利用了JavaScript的继承机制，使得代码更加符合JavaScript的编程习惯。优雅性：通过提供默认实现，避免了在子类中必须实现所有方法的强制性要求，从而提高了代码的优雅性。灵活性：子类可以自由地选择覆盖哪些钩子方法，以及覆盖后的行为是什么。
设计模式总结：建型与结构型模式详解
"这篇文章除了标题'设计模式总结(1)'，还涉及了设计模式的分类，包括创建型、结构型和行为型设计模式的概述。文章着重讲解了创建型模式中的SingletonPattern（单例模式），并对其意图和适用性进行了详细描述，同时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值