设计模式之十：Composite(转)

一、功能 
　　表示“部分-整体”关系，并使用户以一致的方式使用单个对象和组合对象。

　　二、结构图

　　上图中，也可以做些扩展，根据需要可以将Leaf和Composite做为抽象基类，从中派生出子类来。

三、优缺点

　　优点：对于Composite模式，也许人们一开始的注意力会集中在它是如何实现组合对象的。但Composite最重要之处在于用户并不关心是组合对象还是单个对象，用户将以统一的方式进行处理，所以基类应是从单个对象和组合对象中提出的公共接口。 
　　缺点：Composite最大的问题在于不容易限制组合中的组件。

四、实现

　　有时需要限制组合中的组件，即希望一个Composite只能有某些特定的Leaf。这个问题我是用多继承和动态类型转换来解决的。假如组合对象Composite1只能包含单个对象ConcreteLeaf1，Composite2可以包含单个对象ConcreteLeaf1和ConcreteLeaf2。如下图所示：

　　上图中的类层次比较多，使用了AbstractLeaf1和AbstractLeaf2，但没使用AbstractComposite1和AbstractComposite2，这个并不重要，也可以把AbstractLeaf1和AbstractLeaf2去掉，这个并不重要，可以根据具体情况决定要不要。 

简单的代码实现如下：

class Component
{
public:
    virtual void operation() = 0 ;
    virtual void Add(Component*) {}
} ;

class AbstractComponent1 : virtual public Component {} ;

class AbstractLeaf1 : virtual public AbstractComponent1 {} ;

class Composite1 : public AbstractComponent1
{
public:
    virtual void operation() { /* do operation */ }
    virtual void Add(Component*) ;
} ;
void Composite1::Add(Component *p)
{
    AbstractComponent1 *pc1 = dynamic_cast＜ABSTRACTCOMPONENT1*＞(p) ;
        if (pc1 == NULL) return ;
    // do add operation
}

class AbstractComponent2 : virtual public Component {} ;

class AbstractLeaf2 : virtual public AbstractComponent2 {} ;

class Composite2 : public AbstractComponent2
{
public:
    virtual void operation() { /* do operation */ }
    virtual void Add(Component*) ;
} ;
void Composite2::Add(Component *p)
{
    AbstractComponent2 *pc2 = dynamic_cast＜ABSTRACTCOMPONENT2*>(p) ;
    if (pc2 == NULL) return ;
    //do add operation
}

class ConcreteLeaf1 : public AbstractLeaf1
{
public:
    virtual void operation() { /* do operation */ }
} ;

class ConcreteLeaf2 : public AbstractLeaf1, public AbstractLeaf2
{
public:
    virtual void operation() { /* do operation */ }
} ;

客户端代码：
    Component *pc1 = new ConcreteLeaf1() ;
    Component *pc2 = new ConcreteLeaf2() ;
    Component *pc3 = new Composite1() ;
    Component *pc4 = new Composite2() ;
    pc3->Add(pc1) ; // ok
    pc3->Add(pc2) ; // ok
    pc3->Add(pc3) ; // ok
    pc3->Add(pc4) ; // fail
    pc4->Add(pc1) ; // fail
    pc4->Add(pc2) ; // ok
    pc4->Add(pc3) ; // fail
    pc4->Add(pc4) ; // ok

有两点需要注意，一是因为用了多继承，所以需要使用virtual inheritance。二是要用dynamic_cast来判断是否允许组合该组件。

　　五、示例代码

class Component
{
public:
    virtual void Operation() = 0 ;
    virtual void Add(Component*) {}
} ;

class Leaf : public Component
{
public:
    virtual void Operation() {}
} ;

class Composite : public Component
{
public:
    virtual void Add(Component *p) { _list.push_back(p) ; }
    virtual void Operation()
    {
        vector< Component* >::const_iterator it ;
        for (it = _list.begin(); it != _list.end(); it++)
            (*it)->Operation() ;
    }
private:
    vector< Component* > _list ;
} ;      

六、实例

　　(1)JUnit中就用的是Composite模式。