c++设计模式

于 2024-09-04 17:06:59 发布
阅读量1k 收藏 6
点赞数 8
文章标签： c++ 设计模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45372314/article/details/141898645
版权

C++ 设计模式是解决常见软件设计问题的通用方法。设计模式提供了一种可复用的解决方案，帮助开发者构建可扩展、灵活且高效的代码。设计模式通常分为三大类：创建型模式、结构型模式和行为型模式。下面介绍一些常见的设计模式以及它们的特点和适用场景。

一、创建型设计模式
创建型模式主要用于对象的创建，封装了对象实例化的过程，目的是提高代码的灵活性和可复用性。

  1. 单例模式（Singleton）
    定义：保证一个类只有一个实例，并提供全局访问点。

特点：

只有一个实例存在，且可以全局访问。
通过一个静态方法获取唯一实例。
应用场景：需要控制对象的唯一性，比如日志记录器、配置管理等。

示例：

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance; // 懒加载，线程安全
        return instance;
    }

private:
    Singleton() {} // 私有构造函数，禁止外部创建实例
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
  1. 工厂方法模式（Factory Method）
    定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

特点：

将对象的创建延迟到子类，避免直接使用 new 关键字。
子类可以扩展新的类而不修改现有代码。
应用场景：需要在运行时决定创建哪种类的对象。

示例：

class Product {
public:
    virtual void use() = 0;
};

class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using Product A\n";
    }
};

class Factory {
public:
    virtual Product* createProduct() = 0;
};

class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};
  1. 抽象工厂模式（Abstract Factory）
    定义：提供一个创建一系列相关或依赖对象的接口，而无需指定具体类。

特点：

用于创建多个相互关联的对象。
客户端无需知道实际创建的是哪个类。
应用场景：适用于需要生成多种产品系列的场景，如不同操作系统的 UI 控件。

示例：

class AbstractFactory {
public:
    virtual Button* createButton() = 0;
    virtual Checkbox* createCheckbox() = 0;
};

class ConcreteFactory1 : public AbstractFactory {
public:
    Button* createButton() override {
        return new Button1();
    }

    Checkbox* createCheckbox() override {
        return new Checkbox1();
    }
};
  1. 建造者模式（Builder）
    定义：将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

特点：

将对象的创建步骤分离出来，使得构建更加灵活。
用户可以控制构建的细节。
应用场景：构建复杂对象时，特别是对象包含多个组件的情况。

示例：

class Product {
public:
    void addPart(const std::string& part) {
        parts.push_back(part);
    }
    void show() const {
        for (const auto& part : parts) {
            std::cout << part << "\n";
        }
    }

private:
    std::vector<std::string> parts;
};

class Builder {
public:
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual Product* getResult() = 0;
};

class ConcreteBuilder : public Builder {
    Product* product = new Product();
public:
    void buildPartA() override {
        product->addPart("PartA");
    }
    void buildPartB() override {
        product->addPart("PartB");
    }
    Product* getResult() override {
        return product;
    }
};

二、结构型设计模式
结构型模式关心类或对象的组合关系，用来解决类之间的继承、组合、依赖等结构问题。

  1. 适配器模式（Adapter）
    定义：将一个类的接口转换为客户希望的另一个接口。

特点：

使不兼容的类能够协同工作。
通过增加适配器来实现不同类的兼容。
应用场景：需要使用现有类但其接口与目标不符时。

示例：

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

class Adaptee {
public:
    void specificRequest() {
        std::cout << "Specific request\n";
    }
};

class Adapter : public Target {
private:
    Adaptee* adaptee;
public:
    Adapter(Adaptee* a) : adaptee(a) {}
    void request() override {
        adaptee->specificRequest();
    }
};
  1. 桥接模式（Bridge）
    定义：将抽象部分与它的实现部分分离，使它们都可以独立变化。

特点：

通过组合而非继承来解决复杂的多维度变化问题。
抽象和实现可以独立扩展。
应用场景：当有多个维度的变化时（如形状、颜色），需要通过组合的方式降低复杂性。

示例：

class Implementor {
public:
    virtual void operationImpl() = 0;
};

class ConcreteImplementorA : public Implementor {
public:
    void operationImpl() override {
        std::cout << "Concrete Implementor A\n";
    }
};

class Abstraction {
protected:
    Implementor* impl;
public:
    Abstraction(Implementor* imp) : impl(imp) {}
    virtual void operation() {
        impl->operationImpl();
    }
};
  1. 组合模式（Composite）
    定义：将对象组合成树形结构以表示部分-整体的层次结构，使客户端可以以一致的方式处理单个对象和组合对象。

特点：

组合对象和单个对象具有相同的接口。
通过递归的方式处理对象集合。
应用场景：当需要处理树形结构的对象时，例如文件系统。

示例：

class Component {
public:
    virtual void operation() = 0;
};

class Leaf : public Component {
public:
    void operation() override {
        std::cout << "Leaf operation\n";
    }
};

class Composite : public Component {
private:
    std::vector<Component*> children;
public:
    void add(Component* component) {
        children.push_back(component);
    }
    void operation() override {
        for (auto& child : children) {
            child->operation();
        }
    }
};

三、行为型设计模式
行为型模式关注对象之间的交互和职责分配，常用于描述对象如何协同工作。

  1. 观察者模式（Observer）
    定义：定义对象间的一对多依赖，当一个对象改变状态时，所有依赖它的对象都会自动收到通知并更新。

特点：

提供了一种对象间的松耦合机制。
适用于一个对象状态变化需要通知多个对象的场景。
应用场景：事件处理系统、订阅-发布机制。

示例：

class Observer {
public:
    virtual void update() = 0;
};

class Subject {
    std::vector<Observer*> observers;
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }
    void notify() {
        for (Observer* observer : observers) {
            observer->update();
        }
    }
};

class ConcreteObserver : public Observer {
public:
    void update() override {
        std::cout << "Observer updated\n";
    }
};
  1. 策略模式（Strategy）
    定义：定义一系列算法，把它们封装起来，并且使它们可以互换使用。

特点：

使算法可以独立于使用它的客户而独立变化。
提供了在运行时选择算法的灵活性。
应用场景：需要在运行时动态选择算法的场景，如不同的排序策略。

示例：

class Strategy {
public:
    virtual void algorithm() = 0;
};

class ConcreteStrategyA : public Strategy {
public:
    void algorithm() override {
        std::cout << "Algorithm A\n";
    }
};

class Context {
    Strategy* strategy;
public:
    Context(Strategy* s) : strategy(s) {}
    void setStrategy(Strategy* s) {
        strategy = s;
    }
    void executeStrategy() {
        strategy->algorithm();
    }
};

总结
设计模式是用于解决常见软件设计问题的最佳实践。通过学习这些模式，可以提高代码的可维护性、可扩展性和复用性。C++ 中常用的设计模式根据需求和应用场景选择合适的设计模式来优化项目设计，能够大大提升项目的质量和开发效率。

weixin_45372314
关注
细谈八种架构设计模式及其优缺点概述
JavaMonsterr的博客
06-15 305
我想这个问题，十个人回答得有十一个答案，因为另外的那一个是大家妥协的结果。哈哈，我理解，架构就是骨架，如下图所示：人类的身体的支撑是主要由骨架来承担的，然后是其上的肌肉、神经、皮肤。架构对于软件的重要性不亚于骨架对人类身体的重要性。这个问题我问过的面试者不下于数十次，回答五花八门，在我看来，模式就是经验，设计模式就是设计经验，有了这些经验，我们就能在特定情况下使用特定的设计、组合设计，这样可以大大节省我们的设计时间，提高工作效率。 作为一个工作10年以上的老码农，经历的系统架构设计也算不少，接下来，我会把工
设计模式——结构型模式
我姓弓长那个张的博客
07-09 2190
结构型模式 结构型模式主要是用于处理类或者对象的组合，它描述了如何来类或者对象更好的组合起来，是从程序的结构上来解决模块之间的耦合问题。它主要包括适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式、代理模式这个七个模式。 五、适配器模式 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。 5.1 前言 接口的改变，是一个需要程序员们必须（虽然很不情愿）接受和处理的普遍问题。程序提供者们修改他们的代码;系统库被修正;各种程序
结构型模式
ByteX的博客
11-05 552
创建型模式的特点和分类 创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。 创建型模式分为以下几种。 单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。 原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。 工厂方法（FactoryMethod...
23种设计模式总结
十二间记，知不足而奋斗，望远山而前行。千里不辞行路远，时光早晚到天涯。
06-25 2206
23三种设计模式汇总
设计模式：创建型、结构型、行为型
最新发布
风不归的乐园
05-18 1258
设计模式：创建型、结构型、行为型
C++设计模式
02-21
火龙果软件工程技术中心C++设计模式之Adapter一、功能　将一个类的接口转换成客户希望的另外一个接口，解决两个已有接口之间不匹配的问题。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。...
C++设计模式.pdf
08-08
C++零基础学习设计模式，23种设计模式精讲，C++开发必备书籍，零基础轻松掌握，每种设计模式附加代码和uml框图！
C++设计模式--基于Qt4开源跨平台开发框架
01-06
《C++设计模式--基于Qt4开源跨平台开发框架》一书主要探讨了如何在C++编程中利用设计模式，并结合Qt4框架进行高效的跨平台应用开发。设计模式是软件工程中的重要概念，它们是经过时间和实践验证的解决特定问题的模板...
c++设计模式全系列+应用场景+实例说明
04-01
1. **工厂模式（Factory Pattern）**：工厂模式是一种创建型设计模式，用于创建对象而无需指定创建对象的具体类。包括简单工厂模式、工厂方法模式和抽象工厂模式。 2. **单例模式（Singleton Pattern）**：单例模式...
GoF的23种设计模式之结构型模式的特点和分类
weixin_34273046的博客
06-05 1076
结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。 由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。 结构型模式分为以下 7 种： 代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访...
设计模式
haruhyuhae的博客
09-13 697
设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化 项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。 什么是 GOF（四人帮，全拼 Gang of Four） 在 1994 年，由 Eri
设计模式——结构型模式简单介绍
页页的博客
08-24 2037
结构型模式 结构型模式旨在通过改变代码结构来达到解耦的目的，使得我们的代码容易维护和扩展。 代理模式 代理，那就要对客户端隐藏真实实现，由代理来负责客户端的所有请求。 用一个代理来隐藏具体实现类的实现细节，通常还用于在真实的实现的前后添加一部分逻辑。 类似一个接口，接口的实现类（代理） Spring中的动态代理有两种： 如果我们的类定义了接口，如 UserService 接口和 UserServiceImpl 实现，那么采用 JDK 的动态代理，感兴趣的读者可以去看看 java.lang.reflect
23种设计模式-七个结构型模式的特点
weixin_44468025的博客
05-29 324
适配器模式：客户需要的接口不对应，需要原来的功能使用（一般会和代理模式和装饰器模式弄模糊）开发过程中：入参接口不对应，但是有的功能已经开发好，可以用适配器模式 代理模式：原来功能不变增加与业务逻辑以外的功能（如性能测试，日志，缓存等）开发过程中：如果需要一些与业务逻辑无关的功能可以使用代理模式。 享元模式：共享内存对象，开发过程中，有的对象被很多地方使用，就共用一个对象就行，能很好的节约内存（外部状态，内部状态） 桥接模式：用聚合代替继承，开发过程中，多维度情况下，可以用聚合代替继承，很好的解耦 装饰器模式
关于“结构型”设计模式的理解
A_love_B的专栏
08-16 1177
结构型设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。 结构型不同于创建型的设计模式，我们已经通过创建型的模式做了一些能构建对象的组件，就好像我们已经能从不同的地方获取建造大楼的材料，钢筋、水泥、石材，接下来的最重要的工作，就是我们以怎样的形式去运用这些材料（对象），我是这样理解，设计模式本来就来源于建筑行业，但是能在软件行业这么流行，是基于我们可以想象的世界...
结构型模式--适配器、装饰器、外观模式（三）
灰猫
04-12 244
结构型模式涉及如何组合类和对象以形成更大的结构。继承的概念被用来组合接口和定义组合对象获得新功能的方式。 结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 适配器模式 定义：将一个类的接口转换成客户期望的另一个接口，使原本接口不兼容的类可以在一起工作。 适用场景：已经存在的类，它的方法和需求不匹配时（方法结果相同或相似） 优点：能提高类的透明...
结构型模式有哪些分别有哪些特点
lishaheshizan的博客
10-31 2420
结构型模式是描述如何将类对象结合在一起，形成一个更大的结构，结构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构模式。 在GoF设计模式中，结构型模式有： 1.适配器模式 Adapter 适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 两个成熟的类需要通信，但是接口不同，由于开闭原则，我们不能
设计模式（二）结构型模式
热门推荐
huopusa的博客
08-04 1万+
Java 中一般认为有23 种设计模式，我们不需要所有的都会，但是其中常用的几种设计模式应该去掌握。 下面列出了所有的设计模式。需要掌握的设计模式我单独列出来了，当然能掌握的越多越好。 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模...
关于设计模式（创建型、结构型、行为型）
Apy
05-04 512
设计模式的概念 设计模式最开始是由GoF（Gang of Four）提出的。他们在书中提供了23种设计模式，并且首次利用java语言程序实现了。设计模式是一种发现，并非发明。 设计模式的主要特点： 与语言无关，可以用多种语言实现。 动态的，随时会有新模式引入。 可以进行定制，对开发人员非常有用。 这是针对目前所有设计问题的好东西。 这是一个卓越的、特别明智的解决问题的方法。 在设计方面，很多东西...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值