23种设计模式的简单概述

995695705

已于 2023-08-29 15:27:40 修改

阅读量109

点赞数

分类专栏：设计模式文章标签：设计模式组合模式

于 2022-08-29 23:03:31 首次发布

本文链接：https://blog.csdn.net/qq_45441318/article/details/126593832

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

23种设计模式

Abstract Factory

提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类

Adapter

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

Bridge

将抽象部分与它的实现部分进行分离，使得它们可以独立的变化

Builder

将一个复杂对象的构建与它的表示进行分离，使得同样的构建过程可以创建不同的表示

Chain of Responsibility

解除请求的发送者和接收者之间的耦合，使得多个对象都有机会处理这个请求，将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它

Command

将请求封装成一个对象，从而使得你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可取消的操作

Composite

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

Decorator

动态地给以一个对象添加一些额外的职责，就拓展功能而言，Decorator模式比生产子类的方式更为灵活

Facade

为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用

Factory Method

定义一个用于创建对象的接口，让子类决定将哪一个类给实例化，Factory Method使一个类的实例化延迟到其子类

Flyweight

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

Interpreter

给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子

Iterator

提供一种方法顺序访问一个聚合对象中的各个元素，而不需要暴露该对象的内部表示

Mediator

用一个中介对象封装一系列的对象交互，中介者使用各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立的改变它们之间的交互

Memento

在不破坏对象封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就于可以将该对象恢复到保存的状态

Observer

定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并且自动刷新

Prototype

用原型实例指定创建的对象的种类，并且通过拷贝这个原型来创建新的对象

Proxy

为其他对象提供一个代理以控制这个对象的访问

Singleton

保证一个类仅有一个实例，并提供一个访问它的全局访问点instance
单例模式分为懒汉模式和饿汉模式
- 饿汉模式：对对象进行预加载，在使用之前就进行实例化，实例化后直接就可以进行使用，比较耗费内存
- 懒汉模式：懒汉模式指先不创建类的对象实例，等需要时再创建。更加灵活，同样不使用的时候不实例化对象，减少内存的损失
- note: 懒汉模式的弊端
  - 对象的操作不具有原子性，在并发的情况下可能同时创建多个对象实例，这个时候就不满足单例产生的条件了。
  - 解决懒汉模式在并发下存在问题大方案有三
    1.在程序初始化的时候，在并发开始前先构造好单例，避免单例进入并发
    2.使用加锁的方式，确保只有一个实例被创建，加锁解锁挺消耗性能的，因此这个方法不太推荐
    3.基于局部静态变量的初始化是线程安全的使用静态局部变量进行类的初始化

//TODO: 基于局部静态变量的初始化是线程安全的使用静态局部变量进行类的初始化
class Singleton {
private:
    Singleton() {}

public:
    static Singleton* getInstance() {
        static Singleton instance;
        return &instance;
    }
};

//下面提供了一个Instance实例，通过实例可以来了解一个单例类的构造方式以及其用途
@getInstance 通过这个函数，拿到一个类实例化的接口，表示这个类，如果为空，就会走默认构造函数，将这个类构造一次，但是在整个程序运行过程中，除非手动销毁，否则只会创建这一个实例
@destoryInstance 销毁创建的实例，通过delete将创建的类释放掉，作用相当于析构函数

！！！ 这个类只能被创建一次，因此其构造函数无法被访问，只要创建，就不能再被这个实例化，即使需要使用这个类进行相关的操作，只能通过调用的方法进行调用，这里的getInstance()代表的就是这类的本身

注意： 构造函数可以传入参数，具体看业务要求，getInstance() 和destoryInstance()都必须是静态的函数，才能通过类名进行调用
class Instance
{ 
public:
    static Instance *getInstance(){
        if(m_instance == nullptr)
            m_instance = new Instance(); 
        return m_instance;    //provide a static interface 
    }
    static void destoryInstace()
    {
        if(m_instance != nullptr)
            delete m_instance;
        m_instance = nullptr;
    }
private:
    Instance(){}
    Instance(const Instance &instance){}
    ~Instance(){};
private: 
   static Instance* m_instance;
};

再实际的开发中，也可以通过使用静态变量的方式去控制一个类的生成，比如在类内定义一个静态的成员函数，在函数析构时设置标志位，在构造时改变标志位状态，达到类似于单例的效果

class Demo
{
pubic:
    Demo()
    {
    	s_RuningCount = true;
    }
	~Demo()
	{
		s_RuningCount = false;
	}
	static bool isRunging()
	{
		reuturn s_RuningCount;
	}
private:
	static bool s_RuningCount；
};

//主函数
int main()
{
	if(!Demo::isRuning)
	{
		//说明没有有实例在运行，可以实例化对象
		Demo demo;
	}
}

tips: 注意把函数声明和函数实现分离