Composite 模式的实现

实现要点：

1．组合模式采用树形结构来实现普遍存在的对象容器，从而将“一对多”的关系转化“一对一”的关系，使得客户代码可以一致地处理对象和对象容器，无需关心处理的是单个的对象，还是组合的对象容器。

2．将“客户代码与复杂的对象容器结构”解耦是组合模式的核心思想，解耦之后，客户代码将与纯粹的抽象接口——而非对象容器的复内部实现结构——发生依赖关系，从而更能“应对变化”。

3．组合模式中，是将“Add和Remove等和对象容器相关的方法”定义在“表示抽象对象的Component类”中，还是将其定义在“表示对象容器的Composite类”中，是一个关乎“透明性”和“安全性”的两难问题，需要仔细权衡。这里有可能违背面向对象的“单一职责原则”，但是对于这种特殊结构，这又是必须付出的代价。

4．组合模式在具体实现中，可以让父对象中的子对象反向追溯；如果父对象有频繁的遍历需求，可使用缓存技巧来改善效率。

5． 客户端尽量不要直接调用树叶类的方法，而是借助其父类（Component）的多态性完成调用，这样可以增加代码的复用性。

使用场景：

以下情况下适用组合模式：

1．你想表示对象的部分-整体层次结构。

2．你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

  /////////////////Component.h////////////////////////

 #pragma once
 class Component
 {
 public:
     virtual ~Component();
     Component();
     virtual void Operation() =  ;
     virtual void Add( Component*);
     virtual void Remove( Component*);
     virtual Component* GetChild(int);
 protected:
 private:
 };

 /////////////////Component.cpp////////////////////////
 #include "Component.h"
 Component::Component()
 {

 }
 Component::~Component()
 {

 }
 void Component::Add( Component* com)
 {

 }

 void Component::Remove( Component* com)
 {

 }
 void Component::Operation()
 {

 }
 Component* Component::GetChild(int index)
 {
     return ;
 }

 /////////////////Composite.h////////////////////////
 #pragma once
 #include "Component.h"
 #include <vector>
 using namespace std;
 class Composite : public Component
 {
 public:
     Composite(const string&);
     ~Composite();
     void Operation() ;
     void Add( Component*);
     void Remove( Component*);
     Component* GetChild(int);
 protected:
 private:
     vector<Component*> comVec ;
     string  _name ;
 };

 /////////////////Composite.cpp////////////////////////
 #include "Composite.h"
 #include "Component.h"
 #include <iostream>
 #include <string>
 using namespace std;

 Composite::Composite(const string& name)
 {
     _name = name ;
 }
 Composite::~Composite()
 {

 }
 void Composite::Operation()
 {
     cout<<"Composite operation : "<<_name<<endl;
     vector<Component*>::iterator iter = comVec.begin();
     for (;iter != comVec.end() ; iter++)
     {

         if (_name == "Com2")
         {
             cout<<"------";
         }
         if (_name == "Com1")
         {
             cout<<"---";
         }

         (*iter)->Operation();
     }

 }
 void Composite::Add( Component* com)
 {
     comVec.push_back(com);
 }
 void Composite::Remove( Component* com)
 {
     for (vector<Component*>::iterator it = comVec.begin() ; it != comVec.end() ;)
     {
         if (com == *it)
         {
             it = comVec.erase(it);
         }
         else
         {
             it++;
         }
     }
 }

 Component* Composite::GetChild(int index)
 {
     return comVec[index] ;
 }

 ////////////////////Leaf.h///////////////////////
 #pragma once
 #include "Component.h"
 #include <iostream>
 #include <string>
 using namespace std;
 class Leaf : public Component
 {
 public:
     Leaf(const string&);
     ~Leaf();
     void Operation();
 protected:
 private:
     string _name;
 };

 Leaf::Leaf(const string& name)
 {
     _name = name ;
 }
 Leaf::~Leaf()
 {

 }
 void Leaf::Operation()
 {
     cout<<"Leaf operation : "<< _name <<endl;
 }

 /////////////////main////////////////////////////
 #include "Component.h"
 #include "Composite.h"
 #include "Leaf.h"
 #include <iostream>
 #include <string>
 using namespace std; 

 int main()
 {
     Component* leaf1 = new Leaf("leaf1") ;
     Component* leaf2 = new Leaf("leaf2") ;
     Component* leaf3 = new Leaf("leaf3") ;
     Component* com1 = new Composite("Com1");
     com1->Add(leaf1);
     com1->Add(leaf2);
     com1->Add(leaf3);

     Component* leaf4 = new Leaf("leaf4") ;
     Component* leaf5 = new Leaf("leaf5") ;
     Component* com2 = new Composite("Com2");
     com2->Add(leaf4);
     com2->Add(leaf5);

     com1->Add(com2);

     com1->Operation();

     getchar();
     return ;
 }