Design Patterns 8: Composite

用组合的模式来表达部分-整体的结构关系，使用户可以用单一的方式来对待处理单个和组合后的对象

#include <list>

struct Component
{
    virtual void Operation() = 0;
    virtual void Add(Component*) {}
    virtual void Remove(Component*) {}
    virtual Component* GetChild(size_t) { return nullptr; }
};

struct Leaf : Component
{
    void Operation() override {}
};

struct Composite : Component
{
    void Operation() override
    {
        for(auto var : children)
        {
            var->Operation();
        }
    }

    void Add(Component* child) override
    {
        children.push_front(child);
    }

    void Remove(Component* child) override
    {
        children.remove(child);
    }

    Component* GetChild(size_t index) override
    {
        if (index >= children.size())
        {
            return nullptr;
        }
        else
        {
            return *(std::next(children.begin(), index));
        }
    }

    std::list<Component*> children;
};

int main()
{
    Composite* comA = new Composite;
    comA->Add(new Leaf);
    comA->Add(new Leaf);

    Composite* comB = new Composite;
    comB->Add(new Leaf);
    comB->Add(new Leaf);
    comB->Add(new Leaf);

    Composite* com = new Composite;
    com->Add(comA);
    com->Add(comB);

    com->Operation();//two Composite::Operation() then five Leaf::Operation() get called
}