问题:
在软件生命周期中,最经常变化的就是需求,需求的变化造成系统频繁的变动。对于一组类,由于需求的变化,它们也需要经常变化,需要经常编译。这样的结果是系统永远也不可能封闭;
解决方案:
Visitor:这是一个接口,每次需求的变动,都是从这个接口继承出来的;
ConcreateVisitor:实现接口的类,里面封装了变化的需求;
Element:需求的抽象,抽象出来的接口;
ConcreateElement:需求的实现类,不可更改;否则这个模式无法适用了;
#include <IOSTREAM>
using namespace std;
class Element;
class Visitor{
public:
virtual VisitA(Element *ele)=0;
virtual VisitB(Element *ele)=0;
virtual ~Visitor(){}
protected:
Visitor(){}
};
class ConcreateVisitorA:public Visitor
{
public:
virtual VisitA(Element *ele)
{
cout<<"类A:客户变动需求1"<<endl;
}
virtual VisitB(Element *ele)
{
cout<<"类B:客户变动需求1"<<endl;
}
ConcreateVisitorA(){}
virtual ~ConcreateVisitorA(){}
};
class ConcreateVisitorB:public Visitor
{
public:
virtual VisitA(Element *ele)
{
cout<<"类A:客户变动需求2"<<endl;
}
virtual VisitB(Element *ele)
{
cout<<"类B:客户变动需求2"<<endl;
}
ConcreateVisitorB(){}
virtual ~ConcreateVisitorB(){}
};
class Element{
public:
virtual void Accept()=0;
void SetVisitor(Visitor *vis)
{
visitor=vis;
}
virtual ~Element(){}
protected:
Element(Visitor *vis)
{
visitor=vis;
}
Visitor *visitor;
};
class ConcreateElementA:public Element{
public:
virtual void Accept()
{
visitor->VisitA(this);
}
ConcreateElementA(Visitor *vis):Element(vis)
{
}
};
class ConcreateElementB:public Element{
public:
virtual void Accept()
{
visitor->VisitB(this);
}
ConcreateElementB(Visitor *vis):Element(vis)
{
}
};
void main()
{
Visitor *visitor=new ConcreateVisitorA;
ConcreateElementA *elementA=new ConcreateElementA(visitor);
ConcreateElementB *elementB=new ConcreateElementB(visitor);
elementA->Accept();
elementB->Accept();
delete visitor;
visitor=new ConcreateVisitorB;
elementA->SetVisitor(visitor);
elementB->SetVisitor(visitor);
elementA->Accept();
elementB->Accept();
delete visitor;
delete elementA;
delete elementB;
}