设计模式-结构型模式-组合模式

最新推荐文章于 2023-05-14 18:22:15 发布
最新推荐文章于 2023-05-14 18:22:15 发布
阅读量674 收藏
点赞数 1
分类专栏： # 结构型模式 文章标签： 设计模式 组合模式 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/125324928
版权

工程源码：

c++设计模式-结构型模式-组合模式icon-default.png?t=M4ADhttps://download.csdn.net/download/qq_40788199/85665241码云：

设计模式-结构型模式-组合模式icon-default.png?t=M4ADhttps://gitee.com/gongguixing/c-design-mode.git

1、组合模式的定义与特点

组合（Composite Pattern）模式的定义：有时又叫作整体-部分（Part-Whole）模式，它是一种将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系，使用户对单个对象和组合对象具有一致的访问性，属于结构型设计模式。

组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点，树形结构图如下。

 由上图可以看出，其实根节点和树枝节点本质上属于同一种数据类型，可以作为容器使用；而叶子节点与树枝节点在语义上不属于用一种类型。但是在组合模式中，会把树枝节点和叶子节点看作属于同一种数据类型（用统一接口定义），让它们具备一致行为。

这样，在组合模式中，整个树形结构中的对象都属于同一种类型，带来的好处就是用户不需要辨别是树枝节点还是叶子节点，可以直接进行操作，给用户的使用带来极大的便利。

组合模式的主要优点有：

  1. 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；
  2. 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；


其主要缺点是：

  1. 设计较复杂，客户端需要花更多时间理清类之间的层次关系；
  2. 不容易限制容器中的构件；
  3. 不容易用继承的方法来增加构件的新功能；

 2、组合模式的结构与实现

1. 模式的结构

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

  1. 抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。（总的抽象类或接口，定义一些通用的方法，比如新增、删除）
  2. 树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。
  3. 树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。


组合模式分为透明式的组合模式和安全式的组合模式。

3、分类

3.1、透明方式

在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。其结构图如图 1 所示。

 3.2、安全方式

在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。其结构图如图 2 所示。

 4、代码实现

假如要访问集合 c0={leaf1,{leaf2,leaf3}} 中的元素，其对应的树状图如图 3 所示。

​

wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw== 编辑

4.2透明组合模式 

抽象构件（Component）角色

#ifndef ICOMPONENT_H
#define ICOMPONENT_H

#include <string>
using namespace std;

// 透明方式
// 抽象构件角色
// 抽象构件（Component）角色：
// 它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。
class IComponent
{
public:
    virtual ~IComponent() {}

    // 添加子对象
    virtual void add(IComponent *c)     = 0;

    // 删除子对象
    virtual void remove(IComponent *c)  = 0;

    // 获取指定子对象
    virtual IComponent* getChild(uint8_t i) = 0;

    // 方法调用
    virtual void operation()            = 0;

    // 释放所有子对象
    virtual void deleteChild()          = 0;

    // 获取唯一标识属性
    virtual string &getKey()            = 0;

    // 获取节点类型
    virtual string &getType()           = 0;
};

#endif // ICOMPONENT_H

树叶构件（Leaf）角色 

#ifndef LEAF_H
#define LEAF_H

#include "icomponent.h"

// 透明方式
// 树叶构件角色
// 树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。
class Leaf : public IComponent
{
public:
    Leaf(const string &key);

    void add(IComponent *c)     override;

    void remove(IComponent *c)  override;

    IComponent* getChild(uint8_t i)override;

    void deleteChild()          override;

    void operation()            override;

    string &getKey()            override;

    string &getType()           override;

private:
    string mKey;
    string mType;
};

#endif // LEAF_H
#include "leaf.h"
#include <iostream>

Leaf::Leaf(const string &key)
    : mKey(key)
{
    mType = "Leaf";
}

void Leaf::add(IComponent *c)
{
}

void Leaf::remove(IComponent *c)
{

}

IComponent *Leaf::getChild(uint8_t i)
{
    return NULL;
}

void Leaf::deleteChild()
{

}

void Leaf::operation()
{
    std::cout << "Leaf: " << mKey << " operation." << std::endl;
}

string &Leaf::getKey()
{
    return mKey;
}

string &Leaf::getType()
{
    return mType;
}

 树枝构件（Composite）角色 / 中间构件

#ifndef COMPOSITE_H
#define COMPOSITE_H

#include "icomponent.h"
#include <vector>

// 透明方式
// 树枝构件角色 / 中间构件
// 树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。
// 它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。
class Composite : public IComponent
{
public:
    Composite(const string &key);

    void add(IComponent *c)     override;

    void remove(IComponent *c)  override;

    IComponent* getChild(uint8_t i)override;

    void deleteChild()          override;

    void operation()            override;

    string &getKey()            override;

    string &getType()           override;

private:
    // 子对象容器
    vector<IComponent*> mChildren;
    // 唯一标识属性
    string mKey;
    // 节点类型
    string mType;
};

#endif // COMPOSITE_H
#include "composite.h"
#include <iostream>

Composite::Composite(const string &key)
    : mKey(key)
{
    mType = "Composite";
}

void Composite::add(IComponent *c)
{
    mChildren.push_back(c);
    std::cout << "Composite: " << mKey << " add ";
    std::cout << c->getType() << ": " << c->getKey() << std::endl;
}

void Composite::remove(IComponent *c)
{
    uint8_t i = 0;
    for (IComponent *p : mChildren)
    {
        // 地址一致则删除
        if (p == c)
        {
            mChildren.erase(mChildren.begin() + i);
            std::cout << "Composite: " << mKey << " remove ";
            std::cout << c->getType() << ": " << c->getKey() << std::endl;
            break;
        }
        i++;
    }
}

IComponent *Composite::getChild(uint8_t i)
{
    if (i <= mChildren.size())
    {
        return mChildren.at(i);
    }

    return NULL;
}

void Composite::deleteChild()
{
    for (IComponent *p : mChildren)
    {
        std::cout << "Composite: " << mKey << " delete ";
        std::cout << p->getType() << ": " << p->getKey() << std::endl;

        // 树枝构件则释放子构件
        if (p->getType().compare("Composite") == 0)
        {
            p->deleteChild();
            delete p;
        }
        // 叶子构件直接释放
        else if (p->getType().compare("Leef") == 0)
        {
            delete p;
        }
    }

    mChildren.clear();
}

void Composite::operation()
{
    for (IComponent *p : mChildren)
    {
        if (p)
        {
            p->operation();
        }
    }
}

string &Composite::getKey()
{
    return mKey;
}

string &Composite::getType()
{
    return mType;
}

 调用示例

#include <iostream>
#include "leaf.h"
#include "composite.h"

#include "sleaf.h"
#include "scomposite.h"

int main()
{
    // 透明方式调用
    // 创建树枝构件
    IComponent *c0 = new Composite("c0");
    IComponent *c1 = new Composite("c1");
    // 创建叶子构件
    IComponent *leaf1 = new Leaf("leaf1");
    IComponent *leaf2 = new Leaf("leaf2");
    IComponent *leaf3 = new Leaf("leaf3");
    // c0添加叶子leaf1
    c0->add(leaf1);
    // c0添加树枝c1
    c0->add(c1);
    // c1添加叶子leaf2
    c1->add(leaf2);
    // c1添加叶子leaf3
    c1->add(leaf3);
    // c0方法调用
    c0->operation();
    // 释放所有子节点
    c0->deleteChild();

    return 0;
}

4.2、安全组合模式

安全式的组合模式与透明式组合模式的实现代码类似，只要对其做简单修改就可以了，代码如下。

抽象构件（Component）角色 

#ifndef ISCOMPONENT_H
#define ISCOMPONENT_H

#include <string>
using namespace std;

// 透明方式
// 抽象构件角色
// 抽象构件（Component）角色：
// 它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。
// 在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成
class ISComponent
{
public:
    virtual ~ISComponent() {}

    // 方法调用
    virtual void operation()            = 0;

    // 获取唯一标识属性
    virtual string &getKey()            = 0;

    // 获取节点类型
    virtual string &getType()           = 0;
};

树叶构件（Leaf）角色：

#ifndef SLEAF_H
#define SLEAF_H

#include "iscomponent.h"

// 安全方式
// 树叶构件角色
// 树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。
class SLeaf : public ISComponent
{
public:
    SLeaf(const string &key);

    void operation()            override;

    string &getKey()            override;

    string &getType()           override;

private:
    string mKey;
    string mType;
};

#endif // SLEAF_H
#include "sleaf.h"
#include <iostream>

SLeaf::SLeaf(const string &key)
    : mKey(key)
{
    mType = "SLeaf";
}

void SLeaf::operation()
{
    std::cout << "SLeaf: " << mKey << " operation." << std::endl;
}

string &SLeaf::getKey()
{
    return mKey;
}

string &SLeaf::getType()
{
    return mType;
}

 树枝构件（Composite）角色 / 中间构件

 

#ifndef SCOMPOSITE_H
#define SCOMPOSITE_H

#include "iscomponent.h"
#include <vector>

// 安全方式
// 树枝构件角色 / 中间构件
// 树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。
// 它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。
class SComposite : public ISComponent
{
public:
    SComposite(const string &key);

    void add(ISComponent * p);

    void remove(ISComponent *c) ;

    ISComponent* getChild(uint8_t i);

    void deleteChild();

    void operation()            override;

    string &getKey()            override;

    string &getType()           override;

private:
    vector<ISComponent*> mChildren;
    string mKey;
    string mType;
};

#endif // SCOMPOSITE_H
#include "scomposite.h"
#include <iostream>

SComposite::SComposite(const string &key)
    : mKey(key)
{
    mType = "SComposite";
}

void SComposite::add(ISComponent *p)
{
    mChildren.push_back(p);
    std::cout << "SComposite: " << mKey << " add ";
    std::cout << p->getType() << ": " << p->getKey() << std::endl;
}

void SComposite::remove(ISComponent *c)
{
    uint8_t i = 0;
    for (ISComponent *p : mChildren)
    {
        if (p == c)
        {
            mChildren.erase(mChildren.begin() + i);
            std::cout << "Composite: " << mKey << " remove ";
            std::cout << c->getType() << ": " << c->getKey() << std::endl;
            break;
        }
        i++;
    }
}

ISComponent *SComposite::getChild(uint8_t i)
{
    if (i <= mChildren.size())
    {
        return mChildren.at(i);
    }

    return NULL;
}

void SComposite::deleteChild()
{
    for (ISComponent *p : mChildren)
    {
        std::cout << "SComposite: " << mKey << " delete ";
        std::cout << p->getType() << ": " << p->getKey() << std::endl;

        if (p->getType().compare("SComposite") == 0)
        {
            SComposite * s = (SComposite*)p;
            if (s)
            {
                s->deleteChild();
            }
            delete p;
        }
        else if (p->getType().compare("SLeef") == 0)
        {
            delete p;
        }
    }

    mChildren.clear();
}

void SComposite::operation()
{
    for (ISComponent *p : mChildren)
    {
        if (p)
        {
            p->operation();
        }
    }
}

string &SComposite::getKey()
{
    return mKey;
}

string &SComposite::getType()
{
    return mType;
}

 调用示例

#include <iostream>
#include "leaf.h"
#include "composite.h"

#include "sleaf.h"
#include "scomposite.h"

int main()
{
    // 安全方式调用
    // 创建树枝构件
    SComposite *sc0 = new SComposite("sc0");
    SComposite *sc1  = new SComposite("sc1");
    // 创建叶子构件
    ISComponent *sleaf1 = new SLeaf("sleaf1");
    ISComponent *sleaf2 = new SLeaf("sleaf2");
    ISComponent *sleaf3 = new SLeaf("sleaf3");
    // sc0添加叶子sleaf1
    sc0->add(sleaf1);
    // sc0添加树枝sc1
    sc0->add(sc1);
    // sc1添加叶子sleaf2
    sc1->add(sleaf2);
    // sc1添加叶子sleaf3
    sc1->add(sleaf3);
    // sc0方法调用
    sc0->operation();
    // 释放所有子节点
    sc0->deleteChild();

    return 0;
}

 

组合模式的应用场景

前面分析了组合模式的结构与特点，下面分析它适用的以下应用场景。

  1. 在需要表示一个对象整体与部分的层次结构的场合。
  2. 要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合。

 

繁星璀璨G
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++设计模式-结构型模式-组合模式
06-16
c++设计模式-结构型模式-组合模式；qt工程；c++简单源码； 组合（Composite Pattern）模式的定义：有时又叫作整体-部分（Part-Whole）模式，它是一种将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系...
设计模式之组合模式(Composite Pattern)
03-04
将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户对单个对象和复合对象的使用具有一致性。
torch.Tensor.is_leaf属性的使用说明
敲代码的小风
01-20 2708
参考链接: torch.Tensor.is_leaf()
Thymeleaf快速入门【基础总结】
Carson's Blog
11-19 6266
Thymeleaf 一、Thymeleaf入门 1. Thymeleaf简介 1.1. 为什么需要Thymeleaf ? 如上图所示, 当用servlet实现动态页面展示的时候，虽然我们可以用writer.write()写出整个页面，以展示动态信息， ​ 但是代码实在是太冗长，根本无法维护，所以需要将视图展示抽取出来，单独作为一个View视图层。 如果只使用HTML作为视图的话，它是无法展示动态数据的，所以我们对HTML产生了新的需求：既能够正常显示页面，又能在页面中包含动态数据部分。
Thymeleaf的基本使用
小马同学
11-14 7474
Thymeleaf 介绍 简单说，Thymeleaf 是一个跟 Velocity、FreeMarker 类似的模板引擎，它可以完全替代 JSP 。相较与其他的模板引擎，它有如下三个极吸引人的特点： 1.Thymeleaf 在有网络和无网络的环境下皆可运行，即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。这是由于它支持 html 原型，然后在 html ...
模板引擎 Thymeleaf 语法
语雀同名：犬豪 yuque.com/qhao
09-21 1250
模板引擎 Thymeleaf 1. Thymeleaf 简介 Thymeleaf[taɪm lif]，百里香叶，是一个流行的模板引擎，该模板引擎采用 Java 语言开发。Java 中常见的模板引擎有 Velocity、Freemaker、Thymeleaf 等。不同的模板引擎都会具有自己的特定的标签体系，而 Thymeleaf 以 HTML 标签为载体，在 HTML 的标签下实现对数据的展示。 Thymeleaf 本身与 SpringBoot 是没有关系的，但 SpringBoot 官方推荐使用 Thyme
组合模式
小门的博客
12-13 118
组合模式组合模式应用场景模式结构实现方式 组合模式 将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系，使用户对单个对象和组合对象具有一致的访问性 优点： 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码； 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”； 缺点： 设计较复杂，客户端需要花更多时间理清类之间的层次关系； 不容易限制容器中的构件； 不容易用继承的方法来增加构件的新功
组合模式（Composite Pattern）
qq_53868937的博客
05-14 1175
组合设计模式是一种结构型设计模式，又名部分整体模式，是用于把一组相似的对象当作一个单一的对象。它允许客户端以统一的方式处理单个对象和组合对象。该模式将对象组合成树形结构，以表现“部分-整体”的关系。如图我们可以看做是一个文件系统，对于这样的结构我们称之为树形结构。在树形结构中可以通过调用某个方法来遍历整个树，当我们找到某个叶子节点后，就可以对叶子节点进行相关的操作。可以将这颗树理解成一个大的容器，容器里面包含很多的成员对象，这些成员对象即可是容器对象也可以是叶子对象。
设计模式总结之Composite Pattern（组合模式）
cooldragon的专栏
08-11 6288
组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
Composite Pattern(组合模式)
03-16
主要是利用工具设计的UML图 博文链接：https://futrueboy.iteye.com/blog/385925
JAVA-设计模式-结构型模式-组合模式
08-10
JAVA-设计模式-结构型模式-组合模式
c++设计模式-结构型模式-桥接模式
06-12
c++设计模式-结构型模式-桥接模式；qt工程，c++简单源码； 桥接（Bridge）模式的定义如下：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度...
系统架构技能之设计模式-组合模式
03-02
一、我们上篇主要讲述了结构型模式中的外观模式，外观模式作为结构型模式中的一个简单又实用的模式，外观模式通过封装细节来提供大粒度的调用， 直接的好处就是，封装细节，提供了应用写程序的可维护性和易用性。...
结构型模式概述（结构型模式的分类）——小马同学@Tian
SigleDog的博客
11-30 225
结构型模式概述（结构型模式的分类） 结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。 由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。 结构型模式的分类 结构型模式分为以下 7 种： 代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。 适配器（Adap
java设计模式之组合模式（Composite）
heidou_2016的博客
11-21 358
在现实生活中，存在很多“部分-整体”的关系，例如，大学中的部门与学院、总公司中的部门与分公司、学习用品中的书与书包、生活用品中的衣月艮与衣柜以及厨房中的锅碗瓢盆等。在软件开发中也是这样，例如，文件系统中的文件与文件夹、窗体程序中的简单控件与容器控件等。对这些简单对象与复合对象的处理，如果用组合模式来实现会很方便。 组合模式的定义与特点 组合（Composite）模式的定义：有时又叫作部分-整体...
设计模式之组合模式
qq784515681的博客
05-26 363
组合模式 看一个学校院系展示需求 编写程序展示一个学校院系结构： 需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。如图： 传统方案解决学校院系展示，如图： 传统方案解决学校院系展示存在的问题分析： 将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的 实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案，不能很好实现的管理的操作，比如对学院、系的添加，删除，遍历等 解决
设计模式之组合模式（复合模式）
D_R的博客
03-22 778
组合模式的特点 首先在实际开发中，会遇到那种具有层次性的那种需求。 就比如我需要开发一个公司系统，里面有总公司邓哥中国集团，也有财务室（财务室每个分公司也必须具备），河南分公司A,河南分公司下面又有郑州分公司B（相当于数据结构里面的子节点，树枝），分公司B下面又可能有其他的小分公司，小财务室（其相当于数据结构里面的叶子节点，树叶，财务室下面不可能有公司吧），但是无论哪里财务室其功能都是一样的，...
图解Java设计模式-23种设计模式
最新发布
08-28
2. 结构型模式（Structural Patterns）： - 适配器模式（Adapter Pattern） - 桥接模式（Bridge Pattern） - 组合模式（Composite Pattern） - 装饰器模式（Decorator Pattern） - 外观模式（Facade Pattern） ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值