组合模式(conposite)c++版本

这是大话设计模式中的组合模式的c++版本

/*
 * conposite.cpp
 *
 *  Created on: Oct 9, 2017
 *      Author: clh01s@163.com
 *      组合模式：使得用户对单个对象
 *      和组合对象的使用具有一致性。
 */
#include <iostream>
#include <vector>
#include <string>
using namespace std;

//虚基类
class Company
{
public:
    Company(string name):name_(name){}
    virtual ~Company(){}
    virtual void Add(Company* c)=0;//增加
    virtual void Remove(Company* c)=0;//删除
    virtual void Display(int depth)=0;//显示
    virtual void LineOfDuty()=0;//执行工作
protected:
    string name_;
};

//具体公司类,实现接口
class ConcreteCompany:public Company
{
public:
    ConcreteCompany(string name):Company::Company(name){}
    void Add(Company* c) override
    {
        //将传入的基类指针添加到向量中
        _childen.push_back(c);
    }

    void Remove(Company* c) override
    {
        if(!_childen.empty())
        {
            for(int i = 0;i < _childen.size();++i)
            {
                if(_childen[i] == c)
                {
                    _childen.erase(_childen.begin()+i);
                }
            }
        }else
        {
            cout<<"没有元素可以删除！！！"<<endl;
        }
    }

    void Display(int depth) override
    {
        for(int i = 0; i < depth;++i)
        {
            cout<<"-";
        }
        cout<<name_<<endl;
        for(int i = 0; i < _childen.size();++i)
        {
            _childen[i]->Display(depth+2);
        }
    }

    void LineOfDuty() override
    {
        for(int i = 0;i < _childen.size();++i)
        {
            _childen[i]->LineOfDuty();
        }
    }
private:
    //我更喜欢使用向量，这里向量和链表的功能都是一样的：存储指向基类的指针
    vector<Company*> _childen;
};

//人力资源部
class HRDepartment:public Company
{
public:
    HRDepartment(string name):Company::Company(name){}

    void Add(Company* c) override {}

    void Remove(Company* c) override {}

    void Display(int depth) override
    {
        for(int i = 0; i < depth;++i)
        {
            cout<<"-";
        }
        cout<<name_<<endl;
    }

    void LineOfDuty() override
    {
        cout<<name_<<"进行员工招聘，培训，管理。"<<endl;
    }
};

//财务部
class FinanceDepartment:public Company
{
public:
    FinanceDepartment(string name):Company::Company(name){}

    void Add(Company* c) override {}

    void Remove(Company* c) override {}

    void Display(int depth) override
    {
        for(int i = 0; i < depth;++i)
        {
            cout<<"-";
        }
        cout<<name_<<endl;
    }

    void LineOfDuty() override
    {
        cout<<name_<<"进行公司财务收支管理。"<<endl;
    }
};


int main()
{
    ConcreteCompany root("北京总公司");
    root.Add(new HRDepartment("总公司人力资源部"));
    root.Add(new FinanceDepartment("总公司财务部"));

    ConcreteCompany* comp = new ConcreteCompany("上海华东分公司");
    comp->Add(new HRDepartment("华东公司人力资源部"));
    comp->Add(new FinanceDepartment("华东公司财务部"));
    root.Add(comp);

    ConcreteCompany* comp1 = new ConcreteCompany("南京办事处");
    comp1->Add(new HRDepartment("南京办事处人力资源部"));
    comp1->Add(new FinanceDepartment("南京办事处财务部"));
    comp->Add(comp1);

    ConcreteCompany* comp2 = new ConcreteCompany("杭州办事处");
    comp2->Add(new HRDepartment("杭州办事处人力资源部"));
    comp2->Add(new FinanceDepartment("杭州办事处财务部"));
    comp->Add(comp2);

    cout<<"公司结构图："<<endl;
    root.Display(1);

    cout<<"各部门职责："<<endl;
    root.LineOfDuty();

    return 0;
}

执行结果：

clh@clh:~/testcode/设计模式$ ./a.out 
公司结构图：
-北京总公司
---总公司人力资源部
---总公司财务部
---上海华东分公司
-----华东公司人力资源部
-----华东公司财务部
-----南京办事处
-------南京办事处人力资源部
-------南京办事处财务部
-----杭州办事处
-------杭州办事处人力资源部
-------杭州办事处财务部
各部门职责：
总公司人力资源部进行员工招聘，培训，管理。
总公司财务部进行公司财务收支管理。
华东公司人力资源部进行员工招聘，培训，管理。
华东公司财务部进行公司财务收支管理。
南京办事处人力资源部进行员工招聘，培训，管理。
南京办事处财务部进行公司财务收支管理。
杭州办事处人力资源部进行员工招聘，培训，管理。
杭州办事处财务部进行公司财务收支管理。

以下内容摘抄自《设计模式》
Composite模式的动机：
在绘图编辑器和图形捕捉系统这样的图形应用程序中，用户可以使用简单的组件创建复杂的图标。用户可以组合多个简单组件以形成一个较大的组件，这些组件又可以组合成更大的组件。简单的实现方法是为text和line这样的土元定义一些类，另外定义一些类作为这些图元的容器类。
而这样的方法存在一个问题：使用这些类的代码必须区别对待图元对象与容器对象，而实际上大多数情况下用户认为它们是一样的。这些类的代码必须区别使用，使得程序更加复杂。Composite模式就可以解决这些问题让用户不必对这些类进行区别。
Composite模式适用于以下情况：
1.你想表示对象的部分-整体层次结构
2.你希望用户忽略组合对象与单个对象的不同，用户将同意地使用组合结构中的所有对象。
Composite模式的优点：
1.定义了包含基本对象和组合对象的类层次结构 基本对象可以被组合对象合成更复杂的组合对象，而这个组合对象又可以被组合。任何用到基本对象的地方都可以使用组合对象。
2.简化客户代码 客户可以一致的使用组合结构和单个对象。通常用户不知道（也不关心）处理的是一个叶子节点还是一个组合组件。这使得在定义组合的那些类中不需要写一些充斥着选择语句的函数。
3.使得更容易增加新类型的组件 新定义的Composite或Leaf子类自动的与已有的结构和客户代码一起工作，客户程序不需要做新的改变。
Composite模式的缺点：
1.使你的设计更加一般化 容易增加新组件也会产生一些问题，那就是很难限制组合中的组件。有时你希望一个组合只能有某些特定的组件。使用Composite时，你不能依赖类型系统施加这些约束，而必须时刻检查。
转载请注明源地址：http://blog.csdn.net/clh01s