【初学设计模式】Composite (组合)

// 所有原创文章转载请注明作者及链接
// blackboycpp(AT)gmail.com
// QQ群： 135202158









类图：











代码实现：



类声明：

/********************************************************************
	File: 		composite.h	
	Author:		blackboy  blackboycpp@gmail.com
	Purpose:	组合模式
	Created:	2011-03-16
	Modified:	2011-03-16   16:53
*********************************************************************/

#ifndef  __COMPOSITE_H__
#define  __COMPOSITE_H__

#include <vector>

namespace blackboycpp
{
    //////////////////////////////////////////////////////////////////////////
    class  Component
    {
    public:
        virtual  void  Operation();
        virtual  void  Add(Component*);
        virtual  void  Remove(Component*);
        virtual  Component*  GetChild(int);
    };

    //////////////////////////////////////////////////////////////////////////
    class  Composite : public Component
    {
    public:
        virtual  void  Operation();
        virtual  void  Add(Component*);
        virtual  void  Remove(Component*);
        virtual  Component*  GetChild(int);
    private:
        std::vector<Component*>  _children;
    };

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

#endif

类实现：

#include <iostream>
#include <algorithm>
#include "composite.h"

namespace blackboycpp
{
    //////////////////////////////////////////////////////////////////////////
    void  Component::Operation()
    {
        std::cout << "Component::Operation()/n";
    }

    void  Component::Add(Component*)
    {
        std::cout << "Component::Add(Component*)/n";
    }

    void  Component::Remove(Component*)
    {
        std::cout << "Component::Remove(Component*)/n";
    }

    Component*  Component::GetChild(int)
    {
        std::cout << "Component::GetChild()/n";
        return 0;
    }
    
    //////////////////////////////////////////////////////////////////////////

    void  Composite::Operation()
    {
        std::cout << "Composite::Operation()/n";

        for(int i=0; i<(int)_children.size(); ++i)
        {
            Component* p =_children[i];
            p->Operation();
        }
    }

    void  Composite::Add(Component* p)
    {
        std::cout << "Composite::Add(Component*)/n";
        _children.push_back(p);
    }

    void  Composite::Remove(Component* p)
    {
        std::cout << "Composite::Remove(Component*)/n";
        std::vector<Component*>::iterator ret = 
                    std::find(_children.begin(), _children.end(), p);
        if(ret != _children.end())
        {
            _children.erase(ret);
        }
    }

    Component*  Composite::GetChild(int idx)
    {
        std::cout << "Composite::GetChild()/n";
        if(idx >= (int)_children.size()) { 
            return 0;
        }
        return _children[idx];
    }

    //////////////////////////////////////////////////////////////////////////
    void  Leaf::Operation()
    {
        std::cout << "Leaf::Operation()/n";
    }

}

main()：

#include <cstdlib>
#include "composite.h"
using namespace blackboycpp;

int main(int argc, char** argv)
{
    Component* c1 = new Leaf;
    Component* c2 = new Leaf;
    Component* c3 = new Composite;
    c3->Add(c1);
    c3->Add(c2);
    Component* c4 = new Composite;
    c4->Add(c3);
    c4->Operation();
    c4->Remove(c3);

    delete c1;
    delete c2;
    delete c3;
    delete c4;

    system("pause");
    return 0;
}