首页 > 其他分享 >设计模式八股

设计模式八股

时间：2023-10-02 18:22:05浏览次数：41  
标签：八股 Observer void Singleton class 设计模式 public subject

UML-Unified Modeling Language 统一建模语言，又称标准建模语言。是用来对软件密集系统进行可视化建模的一种语言。

进行设计时经常使用这种方法进行建模

 

创建型模式：

单例模式：

局部静态变量懒汉式，在第一次调用函数时才对其进行初始化，因为局部静态变量只能被初始化一次，即便有多线程对其初始化操作，也只有其中一个线程会成功，其他线程对其进行的初始化都会无效。

#include <bits/stdc++.h>

using namespace std;

class Singleton{
    public:
        static Singleton& getInstance(){
            static Singleton instance;
            return instance;
        }
    private:
        Singleton() = default;
        ~Singleton() = default;
        Singleton(const Singleton&) = delete;
        Singleton& operator=(const Singleton&) = delete;
        Singleton(Singleton&&) = delete;
        Singleton& operator=(Singleton&&) = delete;
};


int main(){
    Singleton* p1 = &Singleton::getInstance();
    Singleton* p2 = &Singleton::getInstance();

    if(p1 == p2){
        cout << "same" << endl;
    }

    return 0;
}

 

抽象工厂模式：

https://www.zhihu.com/search?type=content&q=%E6%8A%BD%E8%B1%A1%E5%B7%A5%E5%8E%82

定义抽象产品（鼠标键盘）、具体产品（联想鼠标联想键盘、雷蛇鼠标雷蛇键盘）、抽象工厂（可以生产鼠标键盘）、具体工厂（联想工厂、雷蛇工厂）。

具体产品继承抽象产品，具体工厂继承抽象工厂并提供接口。

客户不用知道生产的具体产品是什么类也不用知道这个工厂是什么类，调用这个抽象工厂类型的指针就行了。指针指向哪个派生类具体工厂就生产哪个工厂的某一类产品

优点：灵活可靠、方便维护拓展起来也比较轻松。

 

#include <bits/stdc++.h>

using namespace std;

class Abstract_keyboard{
    public:
        virtual void showTag() = 0;
};

class Abstract_mouse{
    public:
        virtual void showTag() = 0;

};

class Lenovo_keyboard: public Abstract_keyboard{
    public:
        void showTag() override{
            cout << "this is lenovo keyboard" << endl;
        }
};

class Lenovo_mouse: public Abstract_mouse{
    public:
        void showTag() override{
            cout << "this is lenovo mouse" << endl;
        }
};

class Razer_keyboard: public Abstract_keyboard{
    public:
        void showTag() override{
            cout << "this is razer keyboard" << endl;
        }
};

class Razer_mouse: public Abstract_mouse{
    public:
        void showTag() override{
            cout << "this is razer mouse" << endl;
        }
};

class Abstract_factory{
    public:
        virtual Abstract_keyboard* createKeyboard() = 0;
        virtual Abstract_mouse* createMouse() = 0;
};

class Lenovo_factory: public Abstract_factory{
    Abstract_keyboard* createKeyboard() override{
        return new Lenovo_keyboard();
    }
    Abstract_mouse* createMouse() override{
        return new Lenovo_mouse();
    }
};

class Razer_factory: public Abstract_factory{
    Abstract_keyboard* createKeyboard() override{
        return new Razer_keyboard();
    }
    Abstract_mouse* createMouse() override{
        return new Razer_mouse();
    }
};

int main(){
    Abstract_factory* p1 = new Lenovo_factory();
    p1->createKeyboard()->showTag();
    p1->createMouse()->showTag();


    p1 = new Razer_factory();
    p1->createKeyboard()->showTag();
    p1->createMouse()->showTag();


    return 0;
}

 

 

结构型模式：

装饰器模式：

https://zhuanlan.zhihu.com/p/92516705

  • 装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有类的一个包装。
  • 这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
  • 主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。
  • 何时使用：在不想增加很多子类的情况下扩展类。
  • 例如：咖啡由咖啡豆加工而来，咖啡又扩展出了美式咖啡，拿铁，摩卡。而美式咖啡，拿铁，摩卡可以在咖啡的基础上做一些属性的装饰来完成，如他们的价格不一样，产地也不一样。为了避免继承自咖啡类，我们用装饰器模式来实现该需求。

怎么用？首先有个咖啡豆基类，然后定义一个装饰器基类，之后通过继承装饰器同时又把原始基类指针作为已经存在的成员变量，对其进行动态的修改与撤销，作为继承的一种替代方案。

优点：比较灵活

缺点：代码复杂了。

 

行为型模式：

观察者模式：

#include <bits/stdc++.h>

using namespace std;

class Subject;

class Observer{
    public:
        Observer(const shared_ptr<Subject>& p): m_subject(p){}

        virtual void update() = 0;
        virtual ~Observer() = default;

    public:
        weak_ptr<Subject> m_subject;
};


class Subject{
    public:
        Subject() : m_value(0){}

        void updateValue(int n){
            m_value = n;
        }
        
        int getValue(){
            return m_value;
        }

        void sendNotify(){
            for(auto o : m_observer){
                o->update();
            }
        }

        void append(const shared_ptr<Observer>& o){
            m_observer.insert(o);
        }


        void erase(const shared_ptr<Observer>& o){
            m_observer.erase(o);
        }
    private:
        int m_value;
        set<shared_ptr<Observer>> m_observer;

};

class ObserverA: public Observer{
    public:
        //using Observer::Observer;
        /*
        using A::A; // c++里构造函数默认是不能被继承的，
        当确定派生类使用基类的构造函数也不会出问题时，可以明确指出要继承基类的构造函数，
        这个using A::A; 就是告诉编译器，这个派生类要继承基类的构造函数
        */
        //注意这里的列表初始化需要对Observer不能对m_subject
        ObserverA(const shared_ptr<Subject>& p): Observer(p){}
        void update() override{
            if(const auto p = m_subject.lock()){
                cout << "A " << p->getValue() << endl;
            }
        }
};

class ObserverB: public Observer{
    public:
        //using Observer::Observer;
        ObserverB(const shared_ptr<Subject>& p): Observer(p){}
        void update() override{
            if(const auto p = m_subject.lock()){
                cout << "B " << p->getValue() << endl;
            }
        }
};


int main() {
  auto subject = std::make_shared<Subject>();
  auto a = std::make_shared<ObserverA>(subject);
  auto b = std::make_shared<ObserverB>(subject);

  subject->append(a);
  subject->append(b);

  subject->updateValue(3);
  subject->sendNotify();  // subject_ value in A: 3\nsubject value in B: 3\n
}

 

模板方法模式：

我有煮茶和煮咖啡两个对象化的事件。

两个都需要做的动作有烧水，倒入杯子

煮茶要做的把茶叶倒进杯子、加柠檬

煮咖啡要做的把咖啡倒入杯子加糖和牛奶。

只是一部分的动作需要进行重写，另一部分可以复用，最后调用模板方法函数即可。

  • 在基类定义一个包含多个操作的方法，每个操作在派生类中实现，基类的这个方法就是模板方法。在 C++ 中这种手法称为 NVI（non-virtual interface），模板方法是一个非虚函数，其中的操作为虚函数，并且作为私有成员不暴露给外部
// Template method
#include <iostream>
using namespace std;


class CoffeineBeverage {
public:
    void prepare_recipe() {
        boil_water();
        brew();
        pour_in_cup();
        add_condiments();
    }
private:
    virtual void brew() {
        cout << "Dripping something through filter." << endl;
    }

    virtual void add_condiments() {
        cout << "Adding something." << endl;
    }
protected:
    void boil_water() {
        cout << "Boiling water." << endl;
    }
    
    void pour_in_cup() {
        cout << "pouring into cup." << endl;
    }
    

};

class Coffee : public CoffeineBeverage{
private:
    virtual void brew() {
        cout << "Dripping coffe through filter." << endl;
    }

    virtual void add_condiments() {
        cout << "Adding sugar and mile." << endl;
    }
};

class Tea : public CoffeineBeverage {
private:
    virtual void brew() {
        cout << "Dripping tea through filter." << endl;
    }

    virtual void add_condiments() {
        cout << "Adding lemon." << endl;
    }
};


/************************* TEST ******************************/
int main(int argc, char **argv)
{
    //CoffeineBeverage *cb = new Coffee;
    //CoffeineBeverage *cb2 = new Tea;
　　
　　　　unique_ptr<Make> p = make_unique<makeCoffee>(); 
    cout << "Coffee:" << endl;
    p->prepare_recipe();
    cout << "Tea:" << endl;
    cb2->prepare_recipe();

    return 0;
}

 

标签：八股,Observer,void,Singleton,class,设计模式,public,subject
From： https://www.cnblogs.com/synapse331/p/17740277.html

相关文章

  • C#设计模式19——装饰器模式的写法
    装饰器模式（DecoratorPattern）是一种结构型设计模式，它允许你动态地给一个对象添加一些额外的职责，而不需要修改这个对象的代码。What（什么）装饰器模式是一种结构型设计模式，它允许你动态地给一个对象添加一些额外的职责，而不需要修改这个对象的代码。在装饰器模式中，你可以定义一个装......
  • 设计模式-策略模式
    设计模式-策略模式1.涉及的角色1）Strategy（策略）Strategy角色负责决定实现策略所必需的接口（API）。在示例程序中，由strategy接口扮演此角色。2）ConcreteStrategy（具体的策略）ConcreteStrategy角色负责实现Strategy角色的接口（API），即负责实现具体的策略（战略、方向、方法和算法）。3）Context（......
  • 软件设计模式系列之二十一——观察者模式
    1观察者模式的定义观察者模式（ObserverPattern）是一种行为型设计模式，它允许对象之间建立一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。这个模式也被称为发布-订阅模式，因为它模拟了一个主题（发布者）与多个观察者（订阅者）之间的关系。观察者......
  • 软件设计模式系列之二十——备忘录模式
    备忘录模式是一种行为型设计模式，它允许我们在不暴露对象内部细节的情况下捕获和恢复对象的内部状态。这个模式非常有用，因为它可以帮助我们实现撤销、恢复和历史记录等功能。在本文中，我们将深入探讨备忘录模式的各个方面，包括定义、示例、结构、实现步骤、代码实现、典型应用场景、......
  • 设计模式-组合模式
    (目录)设计模式-组合模式什么是组合模式设计模式？组合模式是一种结构型设计模式，它允许将对象组合成树状结构来表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。在组合模式中，有两种主要类型的对象：叶子对象和组合对象。叶子对象是没有子对象......
  • 设计模式
    模式是指从某个具体的形式中得到的一种抽象，在特殊的非任意性的环境中，该形式不断地重复出现。软件架构的模式描述了一个出现在特定设计语境中的特殊的再现设计问题，并为它的解决方案提供了一个经过充分验证的通用图示。解决方案图示通过描述其组成构件及其责任和相互关系以及它们的协......
  • 软件设计模式系列之十八——迭代器模式
    1模式的定义迭代器模式是一种行为型设计模式，它允许客户端逐个访问一个聚合对象中的元素，而不暴露该对象的内部表示。迭代器模式提供了一种统一的方式来遍历不同类型的集合，使客户端代码更加简洁和可复用。2举例说明为了更好地理解迭代器模式，让我们考虑一个简单的例子：一个图书馆......
  • Mybatis中的设计模式
    最近在看《通用源码阅读指导书：Mybatis源码详解》，这本书一一介绍了Mybatis中的各个包的功能，同时也涉及讲了一些阅读源码的技巧，还讲了一些源码中涉及的设计模式，这是本篇文章介绍的内容在多说一点这本书，Mybatis是大部分Java开发者都熟悉的一个框架，通过这本书去学习如何阅读源码非常......
  • 设计模式-建造者模式
    (目录)设计模式-建造者模式什么是建造者设计模式？建造者模式是一种创建型设计模式，它允许你按照特定的步骤创建复杂对象。它将对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。建造者模式通常用于创建具有复杂结构的对象，例如需要多个步骤或多个部件来构建的对......
  • JAVA 单例设计模式
    单例模式（SingletonPattern）是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99