设计模式之组合模式

虚基类

#pragma once
class Component
{
public:
    Component();
    virtual ~Component();

public:
    virtual void Operation() = 0;

    virtual void Add(const Component &com);

    virtual void Remove(const Component &com);

    virtual Component *GetChild(int index);
};

#include "Component.h"


Component::Component()
{
}


Component::~Component()
{
}

void Component::Add(const Component &com)
{

}

void Component::Remove(const Component &com)
{

}

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

 

派生管理类

#pragma once
#include "Component.h"
#include <vector>

class Composite :
    public Component
{
public:
    Composite();
    ~Composite();

public:
    void Operation();

    void Add(Component *com);

    void Remove(Component *com);

    Component *GetChild(int index);

private:
    std::vector<Component *> m_vec_com;
};

#include "Composite.h"
#include <iostream>


Composite::Composite()
{
}


Composite::~Composite()
{
//内存释放

    for (std::vector<Component *>::iterator it = m_vec_com.begin(); it < m_vec_com.end(); it++)
    {
        delete *it;
        *it = NULL;
    }
    std::vector<Component *>().swap(m_vec_com);　　//不能用m_vec_com.clear()

    std::cout << "size:" << m_vec_com.capacity() << std::endl;　　//用来检测是否完全释放

}

void Composite::Operation()
{
    std::vector<Component *>::iterator it = m_vec_com.begin();
    for (; it != m_vec_com.end(); it++)
    {
        (*it)->Operation();
    }
}

void Composite::Add(Component *com)
{
    m_vec_com.push_back(com);
}

void Composite::Remove(Component *com)
{
    std::vector<Component *>::iterator it = m_vec_com.begin();
    for (; it != m_vec_com.end(); it++)
    {
        if ((*it) == com)
        {
            it = m_vec_com.erase(it);
            break;
        }
    }
}

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

 

被管理的类

#pragma once
#include "Component.h"
class Leaf :
    public Component
{
public:
    Leaf();
    ~Leaf();

    void Operation();
};

#include "Leaf.h"
#include <iostream>


Leaf::Leaf()
{
}


Leaf::~Leaf()
{
}

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

 

测试

#include <iostream>
#include "Leaf.h"
#include "Composite.h"

int main()
{
    Leaf *leaf = new Leaf();　　//释放交给存放这个指针容器
    leaf->Operation();

    Leaf *leaf2 = new Leaf();
    leaf2->Operation();

    Composite *posite = new Composite();

    posite->Add(leaf);

    posite->Add(leaf2);

    posite->Operation();

    Component *ponent = posite->GetChild(0);

    ponent->Operation();　　//指向Leaf的接口

　　 if(ponent)
　　 {
　　　　delete ponent;
　　　　ponent = NULL;
　　 }

    std::cout << "Hello World!\n"; 
}