Composite 模式-GoF 23 种设计模式精解系列-附 C++实现源码

前言

尊重原创，本系列文本解析部分主要基于Candidate for Master’s Degree School of Computer Wuhan University的K_Eckel（[email protected]）《设计模式精解-GoF 23 种设计模式解析附 C++实现源码》。为了避免重造轮子，本系列博文对源码在ubuntu16.04下做了验证并上传到了gitee，再次感谢。

如有问题，可邮件联系我([email protected])并共同探讨解决方案。

Composite 模式简介：

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。

这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。

问题

在开发中,我们经常可能要递归构建树状的组合结构,Composite 模式则提供了很好的解决方案。

模式选择

Composite 模式的典型结构图为:

图 1:Composite Pattern 结构图

实现

完整代码示例(code)

Composite 模式的实现起来很简单,这里为了方便初学者的学习和参考,将给出完整的实现代码(所有代码采用 C++实现,并在 Visual Studio Code，Version: 1.36.1 下测试运行)。

源码gitee地址：点击这里

代码目录结构：

patten@patten-hp:~/workspace/others/cpp/designPatterns/structuralPattern/Composite/src$ tree ../
../
├── include
│   ├── Component.h
│   ├── Composite.h
│   └── Leaf.h
└── src
    ├── Component.cpp
    ├── Composite.cpp
    ├── Leaf.cpp
    └── main.cpp

2 directories, 7 files

Component.h：

// Component.h

#ifndef _COMPONENT_H_
#define _COMPONENT_H_

class Component {
 private:
  /* data */
 public:
  Component(/* args */);
  virtual ~Component();

  virtual void Operation() = 0;
  virtual void Add(const Component&);
  virtual void Remove(const Component&);
  virtual Component* GetChild(int);

};

#endif //~_COMPONENT_H_

Component.cpp：

//Component.cpp

#include "../include/Component.h"

Component::Component(/* args */) {}
Component::~Component() {}
void Component::Add(const Component& com) {}
Component* Component::GetChild(int index) { return 0; }
void Component::Remove(const Component& com){}

Composite.h：

//Composite.h

#ifndef _COMPOSITE_H_
#define _COMPOSITE_H_

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

using namespace std;

class Composite:public Component
{
private:
    vector<Component*> comVec;

public:
    Composite();
    ~Composite();

    void Operation();
    void Add(Component* com);
    void Remove(Component* com);
    Component* GetChild(int index);

};

#endif //~_COMPOSITE_H_

Composite.cpp：

// Composite.cpp

#include "../include/Composite.h"
#include "../include/Component.h"

Composite::Composite() { vector<Component*>::iterator itend = comVec.end(); }
Composite::~Composite() {}
void Composite::Operation() {
  vector<Component*>::iterator comIter = comVec.begin();
  for (; comIter != comVec.end(); comIter++) {
    (*comIter)->Operation();
  }
}
void Composite::Add(Component* com) { comVec.push_back(com); }
void Composite::Remove(Component* com) {
    comVec.pop_back();
}
Component* Composite::GetChild(int index) { return comVec[index]; }

Leaf.h：

//Leaf.h

#ifndef _LEAF_H_
#define _LEAF_H_

#include "Component.h"

class Leaf:public Component
{
private:
    /* data */
public:
    Leaf(/* args */);
    ~Leaf();
    void Operation();
};

#endif //~_LEAF_H_

Leaf.cpp：

// Leaf.cpp

#include "../include/Leaf.h"
#include <iostream>

using namespace std;

Leaf::Leaf(/* args */) {}

Leaf::~Leaf() {}

void Leaf::Operation() { printf("Leaf operation..... \n"); }

main.cpp：

// main.cpp

#include <iostream>
#include "../include/Component.h"
#include "../include/Composite.h"
#include "../include/Leaf.h"

using namespace std;

int main(int argc, char* argv[]) {
  Leaf* l = new Leaf();
  l->Operation();
  Composite* com = new Composite();
  com->Add(l);
  com->Operation();
  Component* ll = com->GetChild(0);
  ll->Operation();

  return 0;
}

代码说明

Composite 模式在实现中有一个问题就是要提供对于子节点(Leaf)的管理策略,这里使用的是 STL 中的 vector,可以提供其他的实现方式,如数组、链表、Hash 表等。

编译运行结果：

patten@patten-hp:~/workspace/others/cpp/designPatterns/structuralPattern/Composite/src$ g++ *.cpp -std=c++11
patten@patten-hp:~/workspace/others/cpp/designPatterns/structuralPattern/Composite/src$ ./a.out 
Leaf operation..... 
Leaf operation..... 
Leaf operation.....

讨论

Composite 模式通过和 Decorator 模式有着类似的结构图,但是 Composite 模式旨在构造类,而 Decorator 模式重在不生成子类即可给对象添加职责。Decorator 模式重在修饰,而Composite 模式重在表示。

前言

目录

创建型模式(Creating Pattern)

结构型模式（Structrual Pattern）

行为型模式（Behavioral Pattern）