设计模式学习[17]---组合模式

文章目录

前言
- 1.引例
- 2.一致性抽象处理
- 3.透明组合模式与安全组合模式
总结

前言

在画类图的时候，类与类之间有组合关系，聚合关系，我本来以为这个组合模式应该是整体与部分的关系，其实设计模式中的组合模式和类图中的组合不是同一个东西。设计模式中的组合模式更像是一个行为统一且存在结构性的关系，例如树形结构。

1.引例

先看下面一个例子，在资源管理器中的文件目录中有这样的一个文件结构，root下面有common.mk,config.mk,makefile三个文件，以及app,signal,_include三个子文件夹，且子文件夹下还有对应的文件。
左侧是结构图，右侧是树形图。
在这里插入图片描述

现在我们用一段代码来实现

#include <iostream>
#include <string>
#include <list>class File
{
public:File(std::string name) :m_sname(name) {}//显示文件名void ShowName(std::string lvlstr){std::cout<<lvlstr << "-" << m_sname << std::endl;}private:std::string m_sname;	//文件名
};class Dir
{
public:Dir(std::string name) :m_sname(name) {};void AddFile(File* pfile){m_childFile.push_back(pfile);}void AddDir(Dir* pDir){m_childDir.push_back(pDir);}void ShowName(std::string lvlstr){//输出本目录名std::cout << lvlstr << "+" << m_sname << std::endl;//输出所包含的文件名lvlstr += "  ";for (auto iter=m_childFile.begin();iter!=m_childFile.end();++iter){(*iter)->ShowName(lvlstr);}//输出所包含的目录名for (auto iter = m_childDir.begin(); iter != m_childDir.end(); ++iter){(*iter)->ShowName(lvlstr);}}
private:std::string m_sname;std::list<File*>m_childFile;std::list<Dir*>m_childDir;
};
int main()
{//(1)创建各种目录,文件对象Dir* pdir1 = new Dir("root");//-----File* pfile1 = new File("common.mk");File* pfile2 = new File("config.mk");File* pfile3 = new File("makefile");//-----Dir* pdir2 = new Dir("app");File* pfile4 = new File("nginx.c");File* pfile5 = new File("ngx_conf.c");//-----Dir * pdir3 = new Dir("signal");File* pfile6 = new File("ngx_signal.c");//-------Dir * pdir4 = new Dir(" include");File* pfile7 = new File("ngx_func.h");File* pfile8 = new File("ngx_signal.h");//(2)构造树形目录结构pdir1->AddFile(pfile1);pdir1->AddFile(pfile2);pdir1->AddFile(pfile3);//-----pdir1->AddDir(pdir2);pdir2->AddFile(pfile4);pdir2->AddFile(pfile5);pdir1->AddDir(pdir3);pdir3->AddFile(pfile6); pdir1->AddDir(pdir4);pdir4->AddFile(pfile7); pdir4->AddFile(pfile8);//(3)输出整个目录结构，只要调用根目录的ShowName方法即可，//每个目录都有自己的ShowName方法负责自己的文件和目录的显示pdir1->ShowName("");//(4)释放资源delete pfile8;delete pfile7;delete pdir4;//-------delete pfile6;delete pdir3;//-------delete pfile5;delete pfile4;delete pdir2;//------delete pfile3;delete pfile2;delete pfile1;delete pdir1;
}

在上述代码中，我们通过ShowName这个函数用来显示当前文件/目录的名称，这种显示名称的行为是否具有一致性？
对于一开始提及的需求，打印出层级结构信息，我们能否将一致性的操作提取出来呢？

如果不提取出来，那就是像上面代码一样，定义了两个类，这两个类之间的成员函数其实没有任何关系，虽然都是叫做ShowName，但分属于不同的类，如果共有的行为再多一点呢？比如输出类型，ShowType这种，其实行为也是一致的。

由此引出我们的组合模式的原理阐述：

组合模式
将一组对象(文件和目录)组织成树形结构以表示“部分-整体”的层次结构(目录中包含文件和子目录)。使得用户对单个对象(文件)和组合对象(日录)的操作/使用/处理(递归遍历并执行ShowName逻辑等)具有一致性。

在这个例子里面，File类型就是部分，Dir类型就是整体的层次结构。

2.一致性抽象处理

对于行为一致的情况，在设计模式中通常用接口进行抽象，我们再引入接口类FileSystem

#include <iostream>
#include <string>
#include <list>class FileSystem
{
public:virtual void ShowName(int level) = 0;//显示名字，用level表示显示的层级，用于显示对齐virtual int Add(FileSystem* pfilesys) = 0;virtual int Remove(FileSystem* pfilesys) = 0;virtual ~FileSystem() {}
};
class File:public FileSystem
{
public:File(std::string name) :m_sname(name) {}void ShowName(int level) override{for (int i = 0; i < level; ++i) { std::cout << "  "; };std::cout << "-" << m_sname << std::endl;}int Add(FileSystem* pfilesys)override{return -1;};int Remove(FileSystem* pfilesys)override{return -1;};private:std::string m_sname;	//文件名
};class Dir :public FileSystem
{
public:Dir(std::string name) :m_sname(name) {};int Add(FileSystem* pfilesys)override{m_child.push_back(pfilesys);return 0;}int Remove(FileSystem* pDir)override{m_child.remove(pDir);return 0;}void ShowName(int level)override{for (int i = 0; i < level; ++i) { std::cout << "  "; };std::cout << "+" << m_sname << std::endl;level++;for (auto iter=m_child.begin();iter!=m_child.end();++iter){(*iter)->ShowName(level);}}
private:std::string m_sname;std::list<FileSystem*>m_child;
};
int main()
{//(1)创建各种目录,文件对象FileSystem* pdir1 = new Dir("root");//-----FileSystem* pfile1 = new File("common.mk");FileSystem* pfile2 = new File("config.mk");FileSystem* pfile3 = new File("makefile");//-----FileSystem* pdir2 = new Dir("app");FileSystem* pfile4 = new File("nginx.c");FileSystem* pfile5 = new File("ngx_conf.c");//-----FileSystem * pdir3 = new Dir("signal");FileSystem* pfile6 = new File("ngx_signal.c");//-------FileSystem * pdir4 = new Dir(" include");FileSystem* pfile7 = new File("ngx_func.h");FileSystem* pfile8 = new File("ngx_signal.h");//(2)构造树形目录结构pdir1->Add(pfile1);pdir1->Add(pfile2);pdir1->Add(pfile3);//-----pdir1->Add(pdir2);pdir2->Add(pfile4);pdir2->Add(pfile5);pdir1->Add(pdir3);pdir3->Add(pfile6);pdir1->Add(pdir4);pdir4->Add(pfile7);pdir4->Add(pfile8);//(3)输出整个目录结构，只要调用根目录的ShowName方法即可，//每个目录都有自己的ShowName方法负责自己的文件和目录的显示pdir1->ShowName(0);//(4)释放资源delete pfile8;delete pfile7;delete pdir4;//-------delete pfile6;delete pdir3;//-------delete pfile5;delete pfile4;delete pdir2;//------delete pfile3;delete pfile2;delete pfile1;delete pdir1;
}

在这里插入图片描述

在上述定义中，用户是指main主函数中的调用代码，一致性指不用区分树叶还是树枝，两者都继承自FileSystem,都具有相同的接口，可以做相同的调用。可以看到，组合模式的设计思路其实就是用树形结构来组织数据，然后通过在树中递归遍历各个节点并在每个节点上统一地调用某个接口(例如,都调用ShowName成员函数)或进行某些运算。总之，组合模式之所以称为结构型模式，是因为该模式提供了一个结构，可以同时包容单个对象和组合对象。组合模式发挥作用的前提是具体数据必须能以树形结构的方式表示，树中包含了单个对象和组合对象。该模式专注于树形结构中单个对象和组合对象的递归遍历(只有递归遍历才能体现出组合模式的价值)，能把相同的操作(FileSystem 定义的接口)应用在单个以及组合对象上，并且可以忽略单个对象和组合对象之间的差别。