第25章 行为型模式—访问者模式

//行为型模式——访问者模式
//场景：扩展客户管理的功能
/*
说明：
1. 公司客户分为企业客户和个人客户
2. 目前的功能：客户提出服务申请
3. 需要扩展的功能：
  (1)客户对公司产品的偏好分析。针对企业和个人客户有不同的分析策略。主要是根据以往购买的历史、潜在购买意向等分析。对于企业客户还要分析其所在行
     业的发展趋势、客户的发展预期等
  (2)客户价值分析。针对企业和个人客户，有不同的分析策略。主要根据购买的金额大小、购买的产品和服务的多少、购买的频率进行分析的。
4. 潜在功能：不同客户的需求调查、满意度分析、客户消费预期分析等。
解决方案：
1. 对象结构就两种：企业客户和个人客户，如何在不想改变类，又要添加新的功能。
2. 定义一个接口代表要新加入的功能。
3. 在客户上添加一个通用的accept方法传入代表新加入的功能对象。
4. 实现新功能对象。
5. 循环访问整个对象结构的类，让这个类来提供符合客户端业务需求的方法。
*/
#include <iostream>
#include <string>
#include <list>

using namespace std;

class EnterpriseCustomer; //前置声明
class PersonalCustomer;   //前置声明

//*****************************访问者的接口(Visitor角色)**************************
class Visitor
{
public:
    //访问企业客户，相当于给企业客户添加访问者的功能
    virtual void visitEnterpriseCustomer(EnterpriseCustomer& ec) = 0;
    //访问个人客户对象，相当于给个人客户添加访问者的功能
    virtual void visitPersonalCustomer(PersonalCustomer& pc) = 0;
};

//**********************************被访问对象(Elment角色))*********************
//被访问对象，客户接口
class Customer
{
private:
    string customerId;
    string name;
public:
    string& getCustomerId(){return customerId;}
    void setCustomerId(string value)
    {
        this->customerId = value;
    }

    string& getName(){return this->name;}
    void setName(string value)
    {
        this->name = value;
    }

    //接受访问者的访问(注意，这里不直接实现，而只是
    //提供一个接口原因是，在方法内部会调用visitor的不同的
    //方法，并且传入一个this指针，而这个指针指的是具体的不同客户)
    virtual void accept(Visitor* visitor) = 0;

    virtual ~Customer(){}
};

//企业客户
class EnterpriseCustomer : public Customer
{
private:
    string linkMan; //联系人
    string linkTelephone; //联系电话
    string registerAddress; //注册地址
public:
    string& getLinkMan(){return linkMan;}
    void setLinkMan(string value)
    {
        linkMan = value;
    }

    string& getLinkTelephone(){return linkTelephone;}
    void setLinkTelephone(string value)
    {
        linkTelephone = value;
    }

    string& getRegisterAddress(){return registerAddress;}
    void setRegisterAddress(string value)
    {
        registerAddress = value;
    }

    void accept(Visitor* visitor)
    {
        //回调访问者对象的相应方法
        visitor->visitEnterpriseCustomer(*this);
    }
};

//个人客户的实现
class PersonalCustomer : public Customer
{
private:
    string telephone;
    int age;
public:

    string& getTelephone(){return telephone;}
    void setTelephone(string value)
    {
        telephone = value;
    }

    int getAge(){return age;}
    void setAge(int value)
    {
        age = value;
    }

    void accept(Visitor* visitor)
    {
        //回调访问者对象的相应方法
        visitor->visitPersonalCustomer(*this);
    }
};

//************************具体的访问者实现*******************************
//实现客户提出服务请求的功能
class ServiceRequestVisitor : public Visitor
{
public:
    //企业客户提出的具体服务请求
    void visitEnterpriseCustomer(EnterpriseCustomer& ec)
    {
        cout <<ec.getName() << "企业提出服务请求" << endl;
    }

    //个人客户提出的具体服务请求
    void visitPersonalCustomer(PersonalCustomer& pc)
    {
        cout <<"客户" <<pc.getName() << "提出服务请求" << endl;
    }
};

//实现对客户偏好的分析
class PredilectionAnalyzeVisitor : public Visitor
{
public:
    //针对企业客户的分析
    void visitEnterpriseCustomer(EnterpriseCustomer& ec)
    {
        //根据以往购买历史、潜在购意向以及客户所在行业的发展趋势
        //客户的发展预期等分析
        cout <<"现在对企业客户" << ec.getName() << "进行产品偏好分析" << endl;
    }

    //针对个人客户的分析
    void visitPersonalCustomer(PersonalCustomer& pc)
    {
        cout <<"现在对个人客户" << pc.getName() << "进行产品偏好分析" << endl;
    }
};

//*********************************ObjectStructure角色*************************
class ObjectStructure
{
private:
    list<Customer*> customers; //客户集合
public:
    //提供给客户端操作的高层接口，具体的功能由客户端传入的访问者决定
    void handleRequest(Visitor* visitor)
    {
        //循环对象结构中的元素，接受访问
        list<Customer*>::iterator iter = customers.begin();
        while (iter != customers.end())
        {
            (*iter)->accept(visitor);
            ++iter;
        }
    }

    //组建对象结构，向对象结构中添加元素
    void addElment(Customer* ele)
    {
        customers.push_back(ele);
    }
    ~ObjectStructure()
    {
        customers.clear();
    }
};

int main()
{
    //创建ObjectStructure对象
    ObjectStructure* pOs = new ObjectStructure();
    ObjectStructure& os = *pOs;
    //准备一些测试数据，创建客户对象，并加入到ObjectStructure
    Customer* cm1 = new EnterpriseCustomer();
    cm1->setName("ABC集团");
    os.addElment(cm1);

    Customer* cm2 = new EnterpriseCustomer();
    cm2->setName("CDE集团");
    os.addElment(cm2);

    Customer* cm3 = new PersonalCustomer();
    cm3->setName("张三");
    os.addElment(cm3);

    //客户提出服务请求，传入服务请求的Visitor
    ServiceRequestVisitor srVistor;
    os.handleRequest(&srVistor);

    //对客户进行偏好分析，传入偏好分析的Visitor
    PredilectionAnalyzeVisitor paVistor;
    os.handleRequest(&paVistor);

    delete cm1;
    delete cm2;
    delete cm3;
    delete pOs;

    return 0;
}
/*输出结果:
ABC集团企业提出服务请求
CDE集团企业提出服务请求
客户张三提出服务请求
现在对企业客户ABC集团进行产品偏好分析
现在对企业客户CDE集团进行产品偏好分析
现在对个人客户张三进行产品偏好分析
*/

//问题：C++只支持单分派，即只根据函数名及参数的静态类型(而不是实际类型)来分派。如何进行双分派的模拟？
//解决思路：见后面的分析：

#include <iostream>
using namespace std;

class Problem;        //前向声明
class SpecialProblem; //前向声明

//定义一级支持
class Supporter
{
public:
    virtual void solve(Problem* p)
    {
        cout << "Solution: Level 1 for common problem" << endl;
    }

    virtual void solve(SpecialProblem* sp)
    {
         cout << "Solution: Level 1 for special problem" << endl;
    }
};

//定义资深支持
class SeniorSupporter : public Supporter
{
public:
    virtual void solve(Problem* p)
    {
        cout << "Solution: Level 2 for common problem" << endl;
    }

    virtual void solve(SpecialProblem* sp)
    {
         cout << "Solution: Level 2 for special problem" << endl;
    }
};

//定义一般问题
class Problem
{
public:
    virtual void accept(Supporter* s)
    {
        s->solve(this); //将Problem自身传给s->solve()，这里是关键
    }
};

//定义特殊问题
class SpecialProblem : public Problem
{
public:
    virtual void accept(Supporter* s)
    {
        s->solve(this); //将SpecialProblem自身传给s->solve()，这里是关键
    }
};

int main()
{
    //演示2次分派
    //一般问题和特殊问题
    Problem* p = new Problem();         //注意，是父类指针
    Problem* sp = new SpecialProblem(); //注意，是父类指针

    //资深解决专家
    Supporter* s = new SeniorSupporter();

    cout <<"演示C++语言的单分派现象"<< endl;
    //演示单分派的效果
    //1. 由于solve是个虚函数时，会通过多态找到SeniorSupporter中的solve方法。同理，如果s指向的实际
    //   对象是父类，则会调用父类的solve方法。这是方法的第1次分派。
    //2. 但由于函数的参数类型是静态绑定的，也就是说s和sp的静态类型是Problem*类型，当编译到s->solve(s)
    //   和s->solve(sp)两行时，编译器是根据s和sp的静态类型，固定地绑定到solve(Problem*)的函数，尽管运
    //   行期s和sp的实际类型不同，但C++并不会根据这两个差别而分别去调用SeniorSupporter中两个不同的重载
    //   函数。即不会进行第2次的分派，这就是所谓的C++只支持方法的单分派。
    s->solve(p);   //参数类型是静态绑定，调用solve(Problem*);
    s->solve(sp);  //参数类型是静态绑定，调用solve(Problem*)，而不是期望的
                   //根据实际类型去调用solve(SpecialProblem*);

    cout << endl;

    cout <<"演示模拟的双分派策略"<< endl;

    //演示2次分派的效果(模拟双分派的主要依据是Problem和Supporter的具体类型进行分派)
    //思路：
    //1. 再看再上面的s->solve(...)这行调用。由于s类提供两种重载版本的solve函数，假如我们在调用该行时，
    //   编译器就能知道到底传入的是Problem*还是SpecialProblem*参数，那就可以正确的调用到相应的函数了。
    //2. 可如何做到这点呢？解决技巧是反客为主，即让参数作为主调函数，并在参数类中提供一个多态的accept
    //   方法，这个函数最主要目的是为了利用多态得到参数对象的实际类型，因为当参数对象p->access时，
    //   由于accept是虚函数，所以会根据p的类型调用父类或子类的access，这样在access函数里面就可以获得p
    //   对象的实际类型，当得这个实际类型后，就可以传给s->solve函数，可access函数时，如果调用s对象的函数呢？
    //   解决方法很简单，就是在设计access函数时，增加一个接收s对象的参数。这种反客为主的曲线调用就是为了获取
    //   参数的实际类型，这属于方法的第1次分派，然后回调s的solve函数进行第2次分派。
    //3. 访问者模式中的accept方法跟这原理是一样的。Visitor::visit()提供了多个重载的版本，但ObjectStrucure中
    //   保存的元素却Elment的父类指针，而不是实际的类型，如果直接将Element*的指针传入visitor.visit()函数时，
    //   是不能分派到相应的重载版本。因此，在Element类中提供一个accept方法来实现双分派策略。
    p->accept(s);   //反客为主，原理见最上面的分析
    sp->accept(s);  //第1次分派：在运行时根据sp的实际类型找到SpecialProblem::accept(Supporter* s)函数
                    //第2次分派：在上述函数的内部执行s->solve(this)时，会根据s的实际类型找到
                    //           SeniorSupporter::solve(SpecialProblem*)，从而正确找到期望的函数。

    return 0;
};
/*输出结果：
演示C++语言的单分派现象
Solution: Level 2 for common problem
Solution: Level 2 for common problem

演示模拟的双分派策略
Solution: Level 2 for common problem
Solution: Level 2 for special problem
*/

#include <iostream>
#include <string>

using namespace std;

class Rectangle;
class Circle;
class Line;

//************************访问者接口************************
class Visitor
{
public:
    //重载了一系列的方法，将Shape的子类作为参数，但是这个Visit也存在改变，
    //这是一个弊端。注意Visit的参数是具体的类型，而不是父类的。因为要为
    //不同的元素增加不同的操作。如果写成父类的，那就必须在Visit函数内进行
    //区别，会造成函数不够过于庞大、职责不清，且不够灵活.
    virtual void visit(Rectangle* shape) = 0; //#1
    virtual void visit(Circle* shape) = 0;    //#2
    virtual void visit(Line* shape) = 0;      //#3

};

//**********************************被访问的对象(Element)***********************
//绘制图形
class Shape
{
public:
    //假设目前只有一个功能draw。
    virtual void draw() = 0;
    /*问题：1.现在要在基类中添加一个将图形整体移动的方法，如
            moveTo(Point p)，则需要改接口。而接口的改变意味
            着各个子类都要随之变化。
            2. 还有一种可能，在基类添加方法，可有些子类并不需要
            这样的方法。
    */

    //预测将来可能会为该类添加新的功能（如moveTo(Point p))
    //传入己经实现新功能的访问者
    virtual void accept(Visitor* v) = 0;
};

class Rectangle : public Shape
{
public:
    void draw()
    {
        cout <<"Rectangle()::draw()" << endl;
    }

    void accept(Visitor* v)
    {
        v->visit(this); //静态绑定，注意this的类型是Rectangle*，所以
                        //调用Visitor::Visit(Rectangle* shape)
    }
};

class Circle : public Shape
{
public:
    void draw()
    {
        cout <<"Circle()::draw()" << endl;
    }
    void accept(Visitor* v)
    {
        v->visit(this); //静态绑定，注意this的类型是Circle*，所以
                        //调用Visitor::Visit(Circle* shape)
    }
};

class Line : public Shape
{
public:
    void draw()
    {
         cout <<"Line()::draw()" << endl;
    }
    void accept(Visitor* v)
    {
        v->visit(this); //静态绑定，注意this的类型是Line*，所以
                        //调用Visitor::Visit(Line* shape)
    }
};

//具体的访问者，为各个类增加新的方法，如MoveTo
class MoveVisitor : public Visitor
{
public:
    void visit(Rectangle* shape)
    {
        cout << "新增Rectangle整体移动的方法" << endl;
    }
    void visit(Circle* shape)
    {
        cout << "新增Circle整体移动的方法" << endl;
    }
    void visit(Line* shape)
    {
        cout << "新增Line整体移动的方法" << endl;
    }
};

//**********************ObjectStructure角色***************************
//这里只为单个类增加新行为
class App
{
    Visitor* visitor;
public:
    App(Visitor* v)
    {
        this->visitor = v;
    }
    void process(Shape* shape)
    {
        //两次分派：
        //1.由于Shape*父类指针，传入具体子类时Accept会发生多态。
        //  找到子类的accept方法的调用对象。
        //2. 分派visit方法，发生在visitor->visit(this)方法中。
        //   会根据this指针所指的具体对象的不同而选择不同重载版本的vist函数。
        shape->accept(visitor);
    }
};

int main()
{
    //创建对象
    Rectangle rt;
    Circle    cc;

    //创建要添加的新方法
    Visitor* vt = new MoveVisitor();

    //动态添加方法
    App* app = new App(vt);

    //为矩形添加新方法(移动操作)
    app->process(&rt);

    //为圆添加新方法(移动操作)
    app->process(&cc);

    //线对象就不做演示了...

    delete vt;
    delete app;

    return 0;
}
/*输出结果：
新增Rectangle整体移动的方法
新增Circle整体移动的方法
*/

//行为型模式——访问者模式
//场景：公司人事信息查询
/*
说明：
1. 公司的人员组织机构树，包括普通员工和部门经理两种类型
2. 要求该机构提供不同格式的报表，即普通员工和部门经理的报表信息有所不同
3. 能分别统计公司普通员工的工资总额和部门经理的总和及整个公司的工资支付总额
4. 预留其它可以功能需求，如今天报表内容可能有所变化。如何做到遵循开闭原则？
*/
#include <iostream>
#include <string>
#include <list>
#include <sstream> //for istringstream/ostringstream

using namespace std;

//
class CommonEmployee; //前置声明，普通员工类
class Manager;        //前置声明，管理员类

class IVisitor
{
public:
    virtual void visit(CommonEmployee& ce) = 0;
    virtual void visit(Manager& mn) = 0;
    //virtual int getTotalSalary() = 0;
};

//展示报表的接口
class IShowVisitor : public IVisitor
{
public:
    //展示报表
    virtual void report() = 0;
};

//汇总表接口
class ITotalVisitor : public IVisitor
{
public:
    //统计所有员工工资总和
    virtual void totalSalary() = 0;
};

//************************************Element角色**********************************
//抽象员工
class Employee
{
private:
    string name; //姓名
    int salary;  //薪水
    string sex;     //性别
public:
    string& getName(){return name;}
    void setName(string value)
    {
        this->name = value;
    }

    int getSalary(){return salary;}
    void setSalary(int value)
    {
        salary = value;
    }

    string getSex(){return sex;}
    void setSex(string value)
    {
        sex = value;
    }

    //允许一个访问者访问
    virtual void accept(IVisitor* visitor) = 0;

    virtual ~Employee(){}
};

//普通员工
class CommonEmployee : public Employee
{
private:
    string job; //工作，这个成员量后面要使用它
public:
    string& getJob(){return job;}
    void setJob(string value)
    {
        job = value;
    }

    void accept(IVisitor* visitor)
    {
        visitor->visit(*this);
    }
};

//管理阶层
class Manager : public Employee
{
private:
    string performance; //业绩
public:
    string& getPerformance(){return performance;}
    void setPerformance(string value)
    {
        performance = value;
    }

    void accept(IVisitor* visitor)
    {
        visitor->visit(*this);
    }
};

//***********************************具体的访问者************************************
//具体的展示表的类
class ShowVisitor : public IShowVisitor
{
private:
    string info;
public:
    void report()
    {
        cout << info << endl;
    }

    //访问普通员工，组装信息
    void visit(CommonEmployee& ce)
    {
        info += getBaseInfo(ce) + "工作:" + ce.getJob() +"tn";
    }

    //访问经理，然后组装信息
    void visit(Manager& mn)
    {
        info += getBaseInfo(mn) + "业绩:" + mn.getPerformance() + "tn";
    }

    //组装出基本信息
    string getBaseInfo(Employee& emp)
    {
        ostringstream oss;
        oss << emp.getSalary();
        string ret = "姓名:" + emp.getName() + "t" +
                     "性别:" + emp.getSex() + "t" +
                     "薪水:" + oss.str() + "t";
        return ret;
    }
};

//具体的汇总表
class TotalVistor : public ITotalVisitor
{
private:
    //部门经理的工资系数是5
    static const int MANAGER_COEFFICIENT = 5;
    //员工的工资系数是2
    static const int COMMONEMPLOYEE_COEFFICIENT = 2;
        //普通员工的工资总和
    int commonTotalSalary;
    //部门经理的工资总和
    int managerTotalSalary;

public:
    TotalVistor()
    {
        commonTotalSalary = 0;
        managerTotalSalary = 0;
    }

    //访问普通员工，计算工资总额
    void visit(CommonEmployee& emp)
    {
        commonTotalSalary += emp.getSalary() * COMMONEMPLOYEE_COEFFICIENT;
    }

    //访问部门经理，计算工资总额
    void visit(Manager& mn)
    {
        managerTotalSalary += mn.getSalary() * MANAGER_COEFFICIENT;
    }

    //计算总工资
    void totalSalary()
    {
        cout <<"本公司的月工资总额是:"  << commonTotalSalary + managerTotalSalary << endl;
    }
};

//*****************************ObjectStructure角色***********************
class ObjectStructure
{
private:
    list<Employee*> emps;
public:
    ObjectStructure()
    {
        //初始化，产生3个员工
        CommonEmployee* emp1 = new CommonEmployee();
        emp1->setName("张三");
        emp1->setSalary(1800);
        emp1->setJob("C++工程师");
        emp1->setSex("男");
        emps.push_back(emp1);

        CommonEmployee* emp2 = new CommonEmployee();
        emp2->setName("李四");
        emp2->setSalary(1900);
        emp2->setJob("页面美工");
        emp2->setSex("女");
        emps.push_back(emp2);

        Manager* emp3 = new Manager();
        emp3->setName("王五");
        emp3->setPerformance("基本上是负值，只会拍马屁");
        emp3->setSalary(18750);
        emp3->setSex("男");
        emps.push_back(emp3);
    }
    ~ObjectStructure()
    {
        list<Employee*>::iterator iter = emps.begin();
        while(iter != emps.end())
        {
            if(*iter != NULL)
                delete (*iter);
            ++iter;
        }
        emps.clear();
    }

    void handleRequest(IVisitor* visitor)
    {
        list<Employee*>::iterator iter = emps.begin();
        while(iter != emps.end())
        {
            if(*iter != NULL)
                (*iter)->accept(visitor);

            ++iter;
        }
    }
};

int main()
{
    //创建公司员工信息
    ObjectStructure os;

    //展示报表的访问者
    IShowVisitor* showVisitor = new ShowVisitor();
    os.handleRequest(showVisitor);
    showVisitor->report();

    //统计工资总额
    ITotalVisitor* totalVisitor = new TotalVistor();
    os.handleRequest(totalVisitor);
    totalVisitor->totalSalary();

    return 0;
}
/*输出结果:
姓名:张三       性别:男 薪水:1800       工作:C++工程师
姓名:李四       性别:女 薪水:1900       工作:页面美工
姓名:王五       性别:男 薪水:18750      业绩:基本上是负值，只会拍马屁

本公司的月工资总额是:101150
*/