设计模式总结（三）

最新推荐文章于 2024-07-20 17:22:42 发布
最新推荐文章于 2024-07-20 17:22:42 发布
阅读量1.1k 收藏 14
点赞数 20
分类专栏： 设计模式 c++总结 文章标签： 设计模式 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yk_rainy/article/details/136407651
版权

上一篇总结了设计模式的创建型模式， 接下来总结一下设计模式的几种结构型模式。

1. 适配器模式

适配器模式允许将一个类的接口转换成客户端所期望的另一个接口。适配器模式通常用于以下情况：

  1. 当你需要使用一个已经存在的类，但是它的接口与你所需要的接口不匹配时。
  2. 当你想要创建一个可复用的类，该类与一些不相关或不可预见的类协同工作时。

适配器模式通过引入一个中间层来解决这些问题，这个中间层就是适配器。适配器将客户端的调用转换为对被适配对象的调用，从而实现了对接口的适配。

下面是一个简单的 C++ 示例，展示了如何使用适配器模式。

假设我们有一个现有的类 Adaptee，它提供了一个名为 specificRequest() 的方法，但是我们需要与一个接口为 Target 的客户端进行交互。

#include <iostream>

// Adaptee类，具有特定接口
class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee's specific request" << std::endl;
    }
};

// Target接口
class Target {
public:
    virtual void request() = 0;
};

// Adapter类，将Adaptee转换为Target
class Adapter : public Target {
private:
    Adaptee *adaptee;

public:
    Adapter(Adaptee *a) : adaptee(a) {}

    void request() override {
        adaptee->specificRequest();
    }
};

// Client使用Target接口
void client(Target *target) {
    target->request();
}

int main() {
    Adaptee *adaptee = new Adaptee();
    Target *adapter = new Adapter(adaptee);

    client(adapter);

    delete adaptee;
    delete adapter;

    return 0;
}

在这个例子中，Adaptee 类是我们需要适配的类，它提供了 specificRequest() 方法。Target 是我们需要与之交互的接口。Adapter 类实现了 Target 接口，并持有一个 Adaptee 对象，在 request() 方法中调用了 Adaptee 的 specificRequest() 方法。最后，在 main() 函数中，我们将 Adaptee 对象传递给 Adapter 对象，然后将 Adapter 对象传递给客户端函数 client()，实现了对接口的适配。

2. 桥接模式

桥接模式将抽象部分与实现部分分离，使它们可以独立地变化。这种模式通过将继承关系转化为关联关系来实现，从而使得抽象部分和实现部分可以独立地变化而不相互影响。

桥接模式主要包含以下角色：

  1. Abstraction（抽象类）：定义了抽象部分的接口，同时维护一个指向实现部分的引用。
  2. Implementor（实现类接口）：定义了实现部分的接口，该接口不一定要与 Abstraction 的接口完全一致。实现类接口并不提供实现，而是声明了一些基本的操作，由具体的实现类来实现。
  3. ConcreteImplementor（具体实现类）：实现了 Implementor 接口，并具体实现其定义的操作。
  4. RefinedAbstraction（扩充抽象类）：扩充了 Abstraction 中定义的接口，通常通过继承 Abstraction 来完成。

以下是一个简单的 C++ 示例，演示了桥接模式的使用：

#include <iostream>

// Implementor（实现类接口）
class Implementor {
public:
    virtual void operationImpl() = 0;
};

// ConcreteImplementorA（具体实现类A）
class ConcreteImplementorA : public Implementor {
public:
    void operationImpl() override {
        std::cout << "Concrete Implementor A operation" << std::endl;
    }
};

// ConcreteImplementorB（具体实现类B）
class ConcreteImplementorB : public Implementor {
public:
    void operationImpl() override {
        std::cout << "Concrete Implementor B operation" << std::endl;
    }
};

// Abstraction（抽象类）
class Abstraction {
protected:
    Implementor *implementor;

public:
    Abstraction(Implementor *impl) : implementor(impl) {}

    virtual void operation() = 0;
};

// RefinedAbstraction（扩充抽象类）
class RefinedAbstraction : public Abstraction {
public:
    RefinedAbstraction(Implementor *impl) : Abstraction(impl) {}

    void operation() override {
        std::cout << "Refined Abstraction operation - ";
        implementor->operationImpl();
    }
};

int main() {
    Implementor *implA = new ConcreteImplementorA();
    Implementor *implB = new ConcreteImplementorB();

    Abstraction *abstraction1 = new RefinedAbstraction(implA);
    Abstraction *abstraction2 = new RefinedAbstraction(implB);

    abstraction1->operation();
    abstraction2->operation();

    delete implA;
    delete implB;
    delete abstraction1;
    delete abstraction2;

    return 0;
}

在这个示例中，Implementor 是实现类接口，定义了实现部分的接口。ConcreteImplementorA 和 ConcreteImplementorB 是具体的实现类，分别实现了 Implementor 接口。Abstraction 是抽象类，它维护了一个指向 Implementor 的引用，并定义了抽象部分的接口。RefinedAbstraction 是扩充抽象类，它继承了 Abstraction 并扩展了其接口。在 main() 函数中，我们创建了两个具体实现类对象和两个扩充抽象类对象，并调用它们的操作方法，实现了桥接模式的使用。

3. 装饰模式

装饰模式允许我们在不改变对象接口的情况下，动态地给对象添加新的功能。装饰模式通过创建一个包装对象来包裹真实对象，然后在保持真实对象接口不变的前提下，向其添加额外的功能。

装饰模式主要包含以下角色：

  1. Component（组件）：定义了一个对象接口，可以为这些对象动态地添加新的功能。
  2. ConcreteComponent（具体组件）：实现了 Component 接口，并定义了具体的对象。
  3. Decorator（装饰者）：持有一个指向 Component 对象的引用，并且与 Component 接口一致，这样可以装饰其他组件。通常是抽象类，它可以为具体组件添加额外的功能。
  4. ConcreteDecorator（具体装饰者）：扩展了 Decorator 类，实现了装饰功能。

下面是一个简单的 C++ 示例，演示了装饰模式的使用：

#include <iostream>

// Component（组件）接口
class Component {
public:
    virtual void operation() = 0;
};

// ConcreteComponent（具体组件）
class ConcreteComponent : public Component {
public:
    void operation() override {
        std::cout << "ConcreteComponent operation" << std::endl;
    }
};

// Decorator（装饰者）抽象类
class Decorator : public Component {
protected:
    Component *component;

public:
    Decorator(Component *comp) : component(comp) {}

    void operation() override {
        if (component != nullptr) {
            component->operation();
        }
    }
};

// ConcreteDecoratorA（具体装饰者A）
class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(Component *comp) : Decorator(comp) {}

    void operation() override {
        Decorator::operation();
        addFunctionality();
    }

    void addFunctionality() {
        std::cout << "Added functionality by ConcreteDecoratorA" << std::endl;
    }
};

// ConcreteDecoratorB（具体装饰者B）
class ConcreteDecoratorB : public Decorator {
public:
    ConcreteDecoratorB(Component *comp) : Decorator(comp) {}

    void operation() override {
        Decorator::operation();
        addMoreFunctionality();
    }

    void addMoreFunctionality() {
        std::cout << "Added more functionality by ConcreteDecoratorB" << std::endl;
    }
};

int main() {
    Component *component = new ConcreteComponent();
    Decorator *decoratorA = new ConcreteDecoratorA(component);
    Decorator *decoratorB = new ConcreteDecoratorB(decoratorA);

    decoratorB->operation();

    delete decoratorB;
    delete decoratorA;
    delete component;

    return 0;
}

在这个示例中，Component 是组件接口，定义了操作方法。ConcreteComponent 是具体组件类，实现了 Component 接口的方法。Decorator 是装饰者抽象类，持有一个指向 Component 对象的引用，并且与 Component 接口一致，以便可以装饰其他组件。ConcreteDecoratorA 和 ConcreteDecoratorB 是具体装饰者类，它们扩展了 Decorator 类，并实现了装饰功能。

在 main() 函数中，我们创建了一个具体组件对象，并使用具体装饰者类对其进行装饰，实现了装饰模式的使用。

4. 组合模式

组合模式允许我们将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户可以使用统一的方式处理单个对象和对象组合。

组合模式主要包含以下角色：

  1. Component（组件）：定义了组合中的对象的共有接口，可以是抽象类或接口，它提供了一个统一的方法来访问组合中的所有对象。
  2. Leaf（叶子）：表示组合中的叶子节点对象，叶子节点没有子节点，它实现了 Component 接口中的方法。
  3. Composite（复合）：表示组合中的容器对象，可以包含其他子节点，它实现了 Component 接口中的方法，并且可以添加、删除、获取子节点等操作。

下面是一个简单的 C++ 示例，演示了组合模式的使用：

#include <iostream>
#include <vector>

// Component（组件）接口
class Component {
public:
    virtual void operation() = 0;
};

// Leaf（叶子）类
class Leaf : public Component {
public:
    void operation() override {
        std::cout << "Leaf operation" << std::endl;
    }
};

// Composite（复合）类
class Composite : public Component {
private:
    std::vector<Component*> children;

public:
    void add(Component *component) {
        children.push_back(component);
    }

    void remove(Component *component) {
        // 在实际应用中，通常需要在这里实现查找并删除子节点的逻辑
        // 这里简化为直接删除对应指针
        children.erase(std::remove(children.begin(), children.end(), component), children.end());
    }

    Component* getChild(int index) {
        if (index >= 0 && index < children.size()) {
            return children[index];
        }
        return nullptr;
    }

    void operation() override {
        std::cout << "Composite operation" << std::endl;
        for (Component *child : children) {
            child->operation();
        }
    }
};

int main() {
    Component *leaf1 = new Leaf();
    Component *leaf2 = new Leaf();
    Component *leaf3 = new Leaf();

    Composite *composite1 = new Composite();
    composite1->add(leaf1);
    composite1->add(leaf2);

    Composite *composite2 = new Composite();
    composite2->add(leaf3);

    Composite *composite = new Composite();
    composite->add(composite1);
    composite->add(composite2);

    composite->operation();

    delete composite;
    delete composite2;
    delete composite1;
    delete leaf3;
    delete leaf2;
    delete leaf1;

    return 0;
}

在这个示例中，Component 是组件接口，定义了操作方法。Leaf 类是叶子类，它实现了 Component 接口的方法。Composite 类是复合类，它实现了 Component 接口，并且可以包含其他子节点。在 main() 函数中，我们创建了多个叶子对象和复合对象，将它们组合成了树形结构，并调用了根节点的 operation() 方法，实现了组合模式的使用。

5. 外观模式

外观模式提供了一个统一的接口，用于访问子系统中的一群接口。外观模式定义了一个高层接口，这个接口使得子系统更容易使用。

外观模式的核心思想是将复杂系统的内部逻辑隐藏在一个简单的接口背后，让客户端只需要通过这个简单的接口与系统交互，而不需要了解系统内部的复杂逻辑。

外观模式主要包含以下角色：

  1. Facade（外观）：提供了一个简单的接口，用于与客户端交互。外观对象将客户端的请求委派给相应的子系统对象来完成具体的工作。
  2. Subsystem（子系统）：实现了系统的功能，是外观对象的组成部分。客户端可以直接访问子系统，但通常通过外观对象来间接访问。

下面是一个简单的 C++ 示例，演示了外观模式的使用：

#include <iostream>

// 子系统A
class SubsystemA {
public:
    void operationA() {
        std::cout << "SubsystemA operation" << std::endl;
    }
};

// 子系统B
class SubsystemB {
public:
    void operationB() {
        std::cout << "SubsystemB operation" << std::endl;
    }
};

// 外观类
class Facade {
private:
    SubsystemA subsystemA;
    SubsystemB subsystemB;

public:
    void operation() {
        subsystemA.operationA();
        subsystemB.operationB();
    }
};

int main() {
    Facade facade;
    facade.operation();

    return 0;
}

在这个示例中，SubsystemA 和 SubsystemB 分别是两个子系统，它们分别实现了系统的一部分功能。Facade 是外观类，它提供了一个简单的接口 operation()，内部调用了 SubsystemA 和 SubsystemB 的方法来完成工作。

在 main() 函数中，我们创建了一个外观对象 facade，并调用了其 operation() 方法，实现了对子系统的访问。通过外观模式，客户端可以直接调用外观对象的方法，而不需要了解系统内部的复杂逻辑，从而简化了客户端的使用方式。

6. 享元模式

享元模式旨在通过共享尽可能多的对象来有效支持大量细粒度的对象。

享元模式的核心思想是尽量减少系统中相似对象的数量，通过共享相似对象的状态来减少内存消耗。在享元模式中，通常将对象的状态分成内部状态（Intrinsic State）和外部状态（Extrinsic State），内部状态是可以共享的，而外部状态则是每个对象单独拥有的。通过这种方式，可以将大量相似对象中的内部状态共享，从而节省内存空间。

享元模式主要包含以下角色：

  1. Flyweight（享元）：定义了一个接口，用于设置和获取外部状态。
  2. ConcreteFlyweight（具体享元）：实现了 Flyweight 接口，并包含内部状态。
  3. FlyweightFactory（享元工厂）：负责创建和管理享元对象，确保可以正确地共享享元对象。

下面是一个简单的 C++ 示例，演示了享元模式的使用：

#include <iostream>
#include <map>

// Flyweight（享元）接口
class Flyweight {
public:
    virtual void operation(int extrinsicState) = 0;
};

// ConcreteFlyweight（具体享元）类
class ConcreteFlyweight : public Flyweight {
private:
    int intrinsicState; // 内部状态，可以共享

public:
    ConcreteFlyweight(int state) : intrinsicState(state) {}

    void operation(int extrinsicState) override {
        std::cout << "ConcreteFlyweight with intrinsic state " << intrinsicState
                  << " and extrinsic state " << extrinsicState << std::endl;
    }
};

// FlyweightFactory（享元工厂）类
class FlyweightFactory {
private:
    std::map<int, Flyweight*> flyweights;

public:
    Flyweight* getFlyweight(int key) {
        if (flyweights.find(key) == flyweights.end()) {
            flyweights[key] = new ConcreteFlyweight(key);
        }
        return flyweights[key];
    }

    ~FlyweightFactory() {
        for (auto& pair : flyweights) {
            delete pair.second;
        }
        flyweights.clear();
    }
};

int main() {
    FlyweightFactory factory;

    Flyweight* flyweight1 = factory.getFlyweight(1);
    flyweight1->operation(100);

    Flyweight* flyweight2 = factory.getFlyweight(2);
    flyweight2->operation(200);

    Flyweight* flyweight3 = factory.getFlyweight(1);
    flyweight3->operation(300);

    return 0;
}

在这个示例中，Flyweight 是享元接口，定义了操作方法。ConcreteFlyweight 是具体享元类，实现了 Flyweight 接口，并包含内部状态。FlyweightFactory 是享元工厂类，负责创建和管理享元对象。

在 main() 函数中，我们创建了一个享元工厂对象 factory，然后通过工厂获取了几个具体享元对象，并分别调用它们的 operation() 方法。可以看到，当获取相同内部状态的享元对象时，工厂会返回同一个对象，从而实现了对相似对象内部状态的共享。

7. 代理模式

代理模式允许通过一个代理对象来控制对另一个对象的访问。代理模式常用于需要在访问对象时增加额外操作的情况，例如延迟加载、权限控制、日志记录等。

代理模式主要包含以下角色：

  1. Subject（主题）：定义了真实对象和代理对象共同的接口，客户端通过这个接口访问真实对象。
  2. RealSubject（真实主题）：定义了真实对象的具体实现。
  3. Proxy（代理）：代理对象，包含了对真实对象的引用，并且与真实对象实现了相同的接口。在客户端请求时，代理对象会执行额外的操作，然后将请求委派给真实对象。

代理模式通常可以分为静态代理和动态代理两种方式。静态代理是在编译时就确定代理对象和真实对象的关系，而动态代理是在运行时动态生成代理对象。

下面是一个简单的 C++ 示例，演示了静态代理模式的使用：

#include <iostream>

// Subject（主题）接口
class Subject {
public:
    virtual void request() = 0;
};

// RealSubject（真实主题）类
class RealSubject : public Subject {
public:
    void request() override {
        std::cout << "RealSubject handles request." << std::endl;
    }
};

// Proxy（代理）类
class Proxy : public Subject {
private:
    RealSubject realSubject;

public:
    void request() override {
        // 在真实主题处理请求前可以执行额外的操作
        std::cout << "Proxy handles request." << std::endl;
        
        // 委派给真实主题处理请求
        realSubject.request();
    }
};

int main() {
    Proxy proxy;
    proxy.request();

    return 0;
}

在这个示例中，Subject 是主题接口，定义了操作方法。RealSubject 是真实主题类，实现了 Subject 接口的方法。Proxy 是代理类，包含了对真实主题对象的引用，并且实现了与真实主题相同的接口。在 request() 方法中，代理对象执行了额外的操作，然后将请求委派给真实主题处理。

在 main() 函数中，我们创建了一个代理对象 proxy，并调用了其 request() 方法，代理对象处理了客户端的请求。

超喜欢下雨天
关注
  • 20
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java设计模式面试题总结
KangJinXuan的博客
08-30 5024
Java设计模式面试题
设计模式总结
04-03
设计模式总结 设计模式是软件设计中一种常见的解决方案，它们可以帮助开发者写出更加灵活、可维护、可扩展的代码。设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。 创建型模式 创建型模式关心对象...
Java常见设计模式总结
张维鹏的博客
09-18 18万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
设计模式23模式介绍
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
设计模式之代理模式分析使用
热门推荐
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
Java中23种设计模式
呜呜老司机的博客家园
10-10 7万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
23种设计模式总结
lgxzzz的博客
05-25 7万+
一、什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛
设计模式期末总结
Thomas_cannon的博客
06-09 3681
设计模式期末总计
Java设计模式学习总结
Java技术江湖
07-08 5650
设计模式 创建型模式 创建型模式 创建型模式的作用就是创建对象，说到创建一个对象，最熟悉的就是 new 一个对象，然后 set 相关属性。但是，在很多场景下，我们需要给客户端提供更加友好的创建对象的方式，尤其是那种我们定义了类，但是需要提供给其他开发者用的时候。 单例 单例模式保证全局的单例类只有一个实例，这样的话使用的时候直接获取即可，比如数据库的一个连接，Spring里的be...
常见的23种设计模式总结
秃头的博客
10-20 3171
创建型模式：单例模式、建造者模式、工厂模式、原型模式。 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式、过滤器模式。 行为型模式：模版模式(模版方法模式)、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式、访问者模式。
常用设计模式总结
yjclsx的博客
07-31 43万+
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结，是可复用面向对象软件的基础。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中...
所有设计模式总结
06-14
上面总结用的是思维导图，（注意：需要用xmind软件打开）设计模式总结，分为三个大类型：创建型，结构型，行为型。总结了它们适用于解决什么问题，用了后所要达到的意图。
设计模式总结.docx
06-13
设计模式是软件设计中的一种最佳实践，用于解决常见的编程问题，提高代码的可重用性、可维护性和可扩展性。在PHP中，设计模式的应用同样广泛，可以帮助开发者更好地组织和管理代码。以下是对给定内容中提到的一些...
趣聊设计模式总结1
08-03
设计模式总结 设计模式是软件开发中的一种解决方案，它提供了一种通用的解决方案来解决常见的软件设计问题。设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。 创建型模式（Creational Patterns） *...
设计模式总结(2)
01-27
设计模式是软件开发中一种通用解决方案的描述，用于解决常见的设计问题。在这篇文章的第二部分中，我们将聚焦于行为型设计模式，特别是Chain Of Responsibility（职责链模式）和Command（命令模式），以及简要提及...
(一)js前端开发中设计模式前篇之对象
峰会路转的博客
07-17 258
改进版与基础版要分开测试，不然会互相影响到。
设计模式实战：在线购物系统的设计与实现
最新发布
qq_40254606的博客
07-20 658
本篇文章将介绍如何设计一个在线购物系统，系统包括购物车、订单处理、支付等功能。我们将通过这一项目，应用组合模式、命令模式、策略模式和观察者模式来解决具体的设计问题。通过本项目，我们综合应用了组合模式、命令模式、策略模式和观察者模式，解决了在线购物系统的设计需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。
(三)js前端开发中设计模式之工厂模式
峰会路转的博客
07-17 274
工厂模式是一种创建型设计模式，它可以帮助我们根据需求创建对象。
java设计模式：02-创建型设计模式-概览
Mr_Air_Boy的博客
07-17 365
创建型模式（Creational Patterns）主要用于处理对象创建的机制，旨在以适当的方式创建对象。这些模式的目的是将对象的创建过程与系统的其他部分分离，以提高系统的灵活性和可扩展性。通过使用创建型模式，可以使系统在创建对象时更加灵活，减少耦合，提高代码的可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值