C++设计模式之——组合模式

最新推荐文章于 2024-05-23 20:19:57 发布
最新推荐文章于 2024-05-23 20:19:57 发布
阅读量787 收藏 9
点赞数 16
文章标签： c++ 设计模式 组合模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqrrjj2011/article/details/136362860
版权

文章目录


组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组织成树形结构，并且能够像处理单个对象一样处理整个组合结构。在组合模式中，组合对象与单个对象（也称为叶子对象或简单对象）有着相同的接口，所以客户端可以一致地对待它们，无需知道处理的是单个对象还是整个组合结构。

组合模式的基本概念：**

  1. Component（抽象构件）：定义了所有对象所共有的接口，包括组合对象和叶子对象。声明了所有用来管理子组件的方法，比如添加、删除和获取子组件等，但在组合对象中实现这些方法，而在叶子对象中则可能提供默认或空实现。

  2. Leaf（叶子节点）：是组合结构中的基本元素，没有子节点，实现了Component接口。

  3. Composite（组合节点）：包含了多个Component对象，可以用来存储和管理它的子部件，同时自身也是Component接口的实现。组合节点提供了用于管理子节点的方法实现。

C++代码案例简述：

下面是一个简单的C++代码示例，展示了如何实现组合模式：

// 抽象构件 Component
class Component {
public:
    virtual ~Component() {}
    virtual void operation() = 0; // 假设这是所有组件都有的通用操作
    virtual void add(Component* child) {} // 在组合节点中实现，在叶子节点中可能是空操作
    virtual void remove(Component* child) {} // 同上
    virtual Component* getChild(int index) { return nullptr; } // 返回指定索引的子组件，叶子节点返回nullptr
};

// 叶子节点 Leaf
class Leaf : public Component {
public:
    void operation() override {
        // 叶子节点的具体实现
    }
};

// 组合节点 Composite
class Composite : public Component {
private:
    vector<Component*> children; // 存储子组件的容器

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

    void remove(Component* child) override {
        auto it = find(children.begin(), children.end(), child);
        if (it != children.end()) {
            children.erase(it);
        }
    }

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

    void operation() override {
        for (auto& child : children) {
            child->operation(); // 递归调用子组件的操作
        }
        // 组合节点自己的具体实现
    }
};

// 使用示例
int main() {
    Leaf* leaf1 = new Leaf();
    Leaf* leaf2 = new Leaf();
    Composite* composite = new Composite();

    composite->add(leaf1);
    composite->add(leaf2);

    composite->operation(); // 会同时调用两个叶子节点以及自身的方法

    delete leaf1;
    delete leaf2;
    delete composite;

    return 0;
}

在这个例子中，Component是抽象基类，Leaf和Composite都是其派生类。Composite内部维护了一个容器来保存子Component对象，并在operation()方法中通过递归来调用每个子组件的operation()方法。这样，无论是单独调用叶子节点的操作，还是调用组合节点的操作，客户端代码都可以保持一致性。

在实际项目中，为了更好地管理和资源释放，建议使用智能指针来代替原始指针，尤其是在C++11之后，可以有效避免内存泄漏和悬挂指针的问题。

当然，我们可以进一步完善上述代码示例，引入智能指针以提高内存管理的安全性。以下是如何使用C++11的std::shared_ptr来重构组合模式的例子：

#include <memory>
#include <vector>

// 抽象构件 Component
class Component {
public:
    virtual ~Component() {}
    virtual void operation() = 0;
    virtual void add(std::shared_ptr<Component> child) = 0;
    virtual void remove(std::shared_ptr<Component> child) = 0;
    virtual std::shared_ptr<Component> getChild(int index) = 0;
};

// 叶子节点 Leaf
class Leaf : public Component {
public:
    void operation() override {
        // 叶子节点的具体实现
    }

    // 对于叶子节点，下述方法为空实现
    void add(std::shared_ptr<Component> child) override {}
    void remove(std::shared_ptr<Component> child) override {}
    std::shared_ptr<Component> getChild(int index) override {
        return nullptr;
    }
};

// 组合节点 Composite
class Composite : public Component {
private:
    std::vector<std::shared_ptr<Component>> children;

public:
    void add(std::shared_ptr<Component> child) override {
        children.push_back(child);
    }

    void remove(std::shared_ptr<Component> child) override {
        auto it = std::find(children.begin(), children.end(), child);
        if (it != children.end()) {
            children.erase(it);
        }
    }

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

    void operation() override {
        for (const auto& child : children) {
            child->operation(); // 递归调用子组件的操作
        }
        // 组合节点自己的具体实现
    }
};

// 使用示例
int main() {
    auto leaf1 = std::make_shared<Leaf>();
    auto leaf2 = std::make_shared<Leaf>();
    auto composite = std::make_shared<Composite>();

    composite->add(leaf1);
    composite->add(leaf2);

    composite->operation(); // 会同时调用两个叶子节点以及自身的方法

    return 0;
}

通过使用std::shared_ptr，我们不再需要手动进行内存管理，当组合对象或叶子对象不再被引用时，它们占用的内存会自动释放。这样不仅提高了代码的健壮性和可维护性，还降低了出现内存泄露的风险。
尽管以上代码已经实现了组合模式的核心思想，但在实际应用中，我们可能还需要考虑其他因素，例如访问子组件的方式可能不仅仅是按索引获取，还可以支持更灵活的方式来遍历所有子组件。下面是对上述代码进行扩展，加入迭代器以便更方便地遍历子组件：

#include <memory>
#include <vector>
#include <iterator> // 引入迭代器功能

// 抽象构件 Component
class Component {
public:
    virtual ~Component() {}
    virtual void operation() = 0;
    virtual void add(std::shared_ptr<Component> child) = 0;
    virtual void remove(std::shared_ptr<Component> child) = 0;

    // 提供迭代器接口，使得可以通过范围for循环遍历子组件
    virtual std::vector<std::shared_ptr<Component>>::const_iterator begin() const = 0;
    virtual std::vector<std::shared_ptr<Component>>::const_iterator end() const = 0;
};

// 叶子节点 Leaf
class Leaf : public Component {
public:
    void operation() override {
        // 叶子节点的具体实现
    }

    // 对于叶子节点，下述方法为空实现
    void add(std::shared_ptr<Component> child) override {}
    void remove(std::shared_ptr<Component> child) override {}
    
    std::vector<std::shared_ptr<Component>>::const_iterator begin() const override {
        static std::shared_ptr<Component> emptyList[] = {};
        return emptyList;
    }

    std::vector<std::shared_ptr<Component>>::const_iterator end() const override {
        static std::shared_ptr<Component> emptyList[] = {};
        return emptyList + 0;
    }
};

// 组合节点 Composite
class Composite : public Component {
private:
    std::vector<std::shared_ptr<Component>> children;

public:
    void add(std::shared_ptr<Component> child) override {
        children.push_back(child);
    }

    void remove(std::shared_ptr<Component> child) override {
        auto it = std::find(children.begin(), children.end(), child);
        if (it != children.end()) {
            children.erase(it);
        }
    }

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

    std::vector<std::shared_ptr<Component>>::const_iterator begin() const override {
        return children.begin();
    }

    std::vector<std::shared_ptr<Component>>::const_iterator end() const override {
        return children.end();
    }

    void operation() override {
        for (const auto& child : children) {
            child->operation(); // 递归调用子组件的操作
        }
        // 组合节点自己的具体实现
    }
};

// 使用示例，现在可以使用范围for循环遍历子组件
int main() {
    auto leaf1 = std::make_shared<Leaf>();
    auto leaf2 = std::make_shared<Leaf>();
    auto composite = std::make_shared<Composite>();

    composite->add(leaf1);
    composite->add(leaf2);

    // 遍历并调用所有子组件的操作
    for (const auto& child : *composite) {
        child->operation();
    }

    return 0;
}

通过添加迭代器接口，现在可以直接使用范围for循环遍历组合对象的所有子组件，这使得代码更加简洁易读，同时也符合STL容器和算法的设计风格。
另外，对于组合模式的应用场景，通常还包括动态构建和修改组合结构的需求。以下是一个更完整的示例，展示如何在运行时创建和调整组合结构，并演示如何利用组合模式简化客户端代码：

#include <memory>
#include <vector>
#include <iostream>
#include <iterator>

// 抽象构件 Component
class Component {
public:
    virtual ~Component() {}
    virtual void operation() const = 0;
    virtual void add(std::shared_ptr<Component> child) = 0;
    virtual void remove(std::shared_ptr<Component> child) = 0;
    virtual std::vector<std::shared_ptr<Component>>::const_iterator begin() const = 0;
    virtual std::vector<std::shared_ptr<Component>>::const_iterator end() const = 0;
};

// 叶子节点 Leaf
class Leaf : public Component {
public:
    explicit Leaf(const std::string& name) : name(name) {}

    void operation() const override {
        std::cout << "Leaf: " << name << std::endl;
    }

    // 对于叶子节点，下述方法为空实现
    void add(std::shared_ptr<Component> child) override {}
    void remove(std::shared_ptr<Component> child) override {}

    std::vector<std::shared_ptr<Component>>::const_iterator begin() const override {
        static std::shared_ptr<Component> emptyList[] = {};
        return emptyList;
    }

    std::vector<std::shared_ptr<Component>>::const_iterator end() const override {
        static std::shared_ptr<Component> emptyList[] = {};
        return emptyList + 0;
    }

private:
    std::string name;
};

// 组合节点 Composite
class Composite : public Component {
public:
    void operation() const override {
        std::cout << "Composite: " << std::endl;
        for (const auto& child : children) {
            child->operation();
        }
    }

    void add(std::shared_ptr<Component> child) override {
        children.push_back(child);
    }

    void remove(std::shared_ptr<Component> child) override {
        auto it = std::find(children.begin(), children.end(), child);
        if (it != children.end()) {
            children.erase(it);
        }
    }

    std::vector<std::shared_ptr<Component>>::const_iterator begin() const override {
        return children.begin();
    }

    std::vector<std::shared_ptr<Component>>::const_iterator end() const override {
        return children.end();
    }

private:
    std::vector<std::shared_ptr<Component>> children;
};

// 客户端代码
int main() {
    auto leaf1 = std::make_shared<Leaf>("Leaf1");
    auto leaf2 = std::make_shared<Leaf>("Leaf2");
    auto composite1 = std::make_shared<Composite>();
    auto composite2 = std::make_shared<Composite>();

    composite1->add(leaf1);
    composite1->add(composite2);
    composite2->add(leaf2);

    // 调用组合结构的操作
    composite1->operation();

    // 动态修改组合结构
    composite1->remove(leaf1);
    composite2->add(leaf1);

    composite1->operation(); // 结构改变后重新调用操作

    return 0;
}

这个示例中，我们创建了一个包含两个叶子节点和一个嵌套组合节点的组合结构，并能够在运行时根据需求动态添加、删除组件。客户端代码只需直接调用组合结构的operation()方法，而无需关心组合的具体结构和内部细节。

python推荐学习汇总连接：
50个开发必备的Python经典脚本(1-10)

50个开发必备的Python经典脚本(11-20)

50个开发必备的Python经典脚本(21-30)

50个开发必备的Python经典脚本(31-40)

50个开发必备的Python经典脚本(41-50)
————————————————

​最后我们放松一下眼睛
在这里插入图片描述

极致人生-010
关注
  • 16
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++设计模式之建造者模式
01-20
建造者模式 在GOF的《设计模式 可复用面向对象软件的基础》中是这样说的：将一个复杂对象的构建与它的表示分离，使得同样的...在《大话设计模式》一书中，例举了一个很好的例子————建造小人。建造一个小人，要分为
C++设计模式之——命令模式
肩上风骋的博客
12-18 1323
命令模式是一种行为型设计模式，它允许将请求封装为一个对象，从而使得可以参数化客户端请求、将请求排队或者记录请求日志，以及支持可撤销的操作。总的来说，命令模式的应用场景主要在于解耦请求与实现，封装接收方具体命令的实现细节，使得请求方的代码架构稳定，具备良好的扩展性。2.创建具体命令类（Concrete Command）：继承自抽象命令类，实现具体的命令操作，同时持有一个命令接收者对象。在C++中，命令模式通常由一个抽象命令类、具体命令类、命令接收者类和调用者类组成。
C++设计模式之组合模式
weixin_42267862的博客
12-27 374
组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。
C++设计模式——适配器模式
Abieai的博客
10-14 478
设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。主要实现了适配器模式。
C++设计模式——组合模式(Composite Pattern)
leonardohaig的博客
06-07 1162
C++设计模式——组合模式 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——组合模式目录定义定义结构代码示例总结使用场景及注意事项优缺点参考资料 定义 定义 Compose objects into tree structures to represent part-whole hierarchies.Composite lets clients treat individual objects and compositions of objects uniformly. 将对象组合成树形结
设计模式C++实现(7)——外观模式、组合模式[参照].pdf
10-14
设计模式C++实现(7)——外观模式、组合模式[参照].pdf
坦克大战——C++游戏代码
04-01
但较之原版，该游戏由C/C++编写PC运行，由字符界面实现游戏画面。原版一辆坦克的子弹未消失之前不能发射第二颗。导致子弹打击远处CD长，近处CD短。该游戏每个子弹都有相同CD，子弹未消失只要CD达到即可发射第二颗，...
Python语言程序设计源代码.zip
08-12
组合数据类型是Python语言区别于其他高级编程语言的一大特色，通过组合数据类型，省去了其他语言各种复杂数据结构的设计，给编程人员带来了极大的方便，这也是Python流行于数据分析领域的原因之一。学习本章，要熟练...
C语言简要（四）
m0_74057302的博客
05-21 338
有没有好心师傅教教孩子逆向和pwn啊°꒰๑'ꀾ'๑꒱°
C语言——函数指针与指针函数
qq_67319052的博客
05-19 627
函数指针与指针函数有什么区别？
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 761
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
Python教程：使用Python和PyQt编写进制转换器工具
复现的博客
05-23 319
在现代计算中，进制转换是一项常见且重要的任务。为了简化这个过程，我们也可以利用Python和PyQt自己写一个直观且易于使用的进制转换器工具。这个工具将支持二进制、八进制、十进制和十六进制的相互转换，并提供良好的用户界面和交互体验。
c语言操作注意事项
dropLin的博客
05-20 216
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
C/C++免杀--原生态(GG)
金灰的博客
05-20 372
看个热闹吧... metasploit payload运行原理浅析(sockedi调用约定是什么) lib/msf/core/payload/windows/reverse_tcp.rb: metasploit-framework/lib/msf/core/payload/windows/reverse_tcp.rb at master · rapid7/metasploit-framework · GitHub 原生态: MSF: #include <Windows
C++质数的那些事（判断指数、区间筛质数、互质等等）
最新发布
A1063348628的博客
05-23 162
质数的定义：若一个正整数除了1和它自身之外不能被任何自然数整除，则该数称为质数，也叫素数。否则为合数。质数的性质：质数的分布较为稀疏，对于一个足够大的数S，不超过S的质数大约有个，也就是说每InN个数约有一个质数，代码： 二、筛出给定区间的质数 代码（欧拉筛（线性筛））： 三、判断两个整数是否互质 代码： 代码会随个人学习进行持续更新，谢谢您的观看！
C语言之函数指针（持续更新）
qq_47607743的博客
05-20 332
C语言指针
介绍一下C++设计模式之原型模式
07-23
原型模式（Prototype Pattern）是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而无需通过显式的实例化过程。原型模式通过克隆（clone）已有对象来创建新对象，从而避免了使用传统的构造函数创建对象的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

极致人生-010

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值