设计模式——组合模式（C++实现）

组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构。

组合模式使得用户对单个对象和组合对象的使用具有一致性。

 

是一种结构型模式

 

 

使用场景：

1、用于对象的部分-整体层次结构，如树形菜单、文件夹菜单、部门组织架构图等；

2、对用户隐藏组合对象与单个对象的不同，使得用户统一地使用组合结构中的所有对象。

 #include <iostream>
 #include <string>
 #include <vector>

 using namespace std;

 class STComponent
 {
 public:
         STComponent()
         {

         }
         STComponent(string strName): m_strName(strName)
         {

         }
         virtual ~STComponent()
         {

         }

         /*
         virtual void Add(STComponent* c);
         virtual void Remove(STComponent* c) ;
         virtual void Display(int iDepth);
         */

         virtual void Add(STComponent* c) = ;
         virtual void Remove(STComponent* c) = ;
         virtual void Display(int iDepth) = ;

         string m_strName;

 };

 class STLeaf: public STComponent
 {
 public:
         STLeaf(string strName): STComponent(strName)
         {

         }

         virtual void Add(STComponent* c)
         {
                 cout<< "Cann't Add to a leaf"<< endl;
         }
         virtual void Remove(STComponent* c)
         {
                 cout<< "Cann't Remove from a leaf"<< endl;
         }
         virtual void Display(int iDepth)
         {
                 cout<< string(iDepth, '-')<< m_strName<< endl;
         }
 };

 class STComposite: public STComponent
 {
 public:
         STComposite(string strName): STComponent(strName)
         {

         }
         ~STComposite()
         {
                 m_vecStComposite.clear();
         }

         virtual void Add(STComponent* c)
         {
                 m_vecStComposite.push_back(c);
         }

         virtual void Remove(STComponent* c)
         {
                 for (typeof(m_vecStComposite.begin()) it = m_vecStComposite.begin(); it != m_vecStComposite.end();)
                 {
                         if (*it == c)
                         {
                                 it = m_vecStComposite.erase(it);
                                 cout<< "erase Succ: "<< (*it)->m_strName<< endl;
                         }
                         else
                         {
                                 ++it;
                         }
                 }
         }

         virtual void Display(int iDepth)
         {
                 cout<< string(iDepth, '-')<< m_strName<< endl;
                 for (size_t i = ; i < m_vecStComposite.size(); ++i)
                 {
                         m_vecStComposite[i]->Display(iDepth+);
                 }
         }

         vector<STComponent*> m_vecStComposite;
 };

 int main(int argc, char* argv[])
 {
         //STLeaf* pstLeaf = new STLeaf("leafA");
         //pstLeaf->Add(NULL);
         //pstLeaf->Remove(NULL);
         //pstLeaf->Display(10);
         //delete pstLeaf;

         STComposite* root = new STComposite("root");
         root->Add(new STLeaf("Leaf A"));
         root->Add(new STLeaf("Leaf B"));

         STComposite* comp = new STComposite("Composite X");
         comp->Add(new STLeaf("Leaf XA"));
         comp->Add(new STLeaf("Leaf XB"));
         root->Add(comp);

         STComposite* comp2 = new STComposite("Composite XY");
         comp2->Add(new STLeaf("Leaf XYA"));
         comp2->Add(new STLeaf("Leaf XYB"));
         comp->Add(comp2);

         STLeaf* pstLeaf = new STLeaf("leaf D");
         root->Add(pstLeaf);
         root->Display();

 //      root->Remove(pstLeaf);
         root->Remove(comp);
         root->Display();

         return ;
 }
 /////////////////////////////
 [root@ ~/learn_code/design_pattern/16_composite]$ ./composite
 -root
 --Leaf A
 --Leaf B
 --Composite X
 ---Leaf XA
 ---Leaf XB
 ---Composite XY
 ----Leaf XYA
 ----Leaf XYB
 --leaf D
 erase Succ: leaf D
 -root
 --Leaf A
 --Leaf B
 --leaf D