设计模式-访问者模式

适用情境 : 把对象和对象上的次要操作分离开,以符合单一职责原则.

// visitor.h
#ifndef VISITOR_H
#define VISITOR_H

class Server;

class Visitor
{
public:
    virtual void VisitServerA(Server* serverA) = 0;
    virtual void VisitServerB(Server* serverB) = 0;
};

#endif // VISITOR_H

// concretevisitora.h
#ifndef CONCRETEVISITORA_H
#define CONCRETEVISITORA_H

#include "visitor.h"

class ConcreteVisitorA : public Visitor
{
public:
    virtual void VisitServerA(Server *serverA);
    virtual void VisitServerB(Server *serverB);
};

#endif // CONCRETEVISITORA_H

// concretevisitora.cpp
#include "concretevisitora.h"
#include <iostream>
#include "server.h"

void ConcreteVisitorA::VisitServerA(Server* serverA)
{
    std::cout << "ConcreteVisitorA visit "<< serverA->m_name << std::endl;
}

void ConcreteVisitorA::VisitServerB(Server *serverB)
{
    std::cout << "ConcreteVisitorA visit "<< serverB->m_name << std::endl;
}

// concretevisitorb.h
#ifndef CONCRETEVISITORB_H
#define CONCRETEVISITORB_H

#include "visitor.h"

class ConcreteVisitorB : public Visitor
{
public:
    virtual void VisitServerA(Server *serverA);
    virtual void VisitServerB(Server *serverB);
};

#endif // CONCRETEVISITORB_H

// concretevisitorb.cpp
#include "concretevisitorb.h"
#include <iostream>
#include "server.h"

void ConcreteVisitorB::VisitServerA(Server* serverA)
{
    std::cout << "ConcreteVisitorB visit "<< serverA->m_name << std::endl;
}

void ConcreteVisitorB::VisitServerB(Server *serverB)
{
    std::cout << "ConcreteVisitorB visit "<< serverB->m_name << std::endl;
}

// server.h
#ifndef SERVER_H
#define SERVER_H

#include "visitor.h"
#include <string>

class Server
{
public:
    std::string m_name;
public:
    virtual void Accept(Visitor* visitor) = 0;

};

#endif // SERVER_H

// concreteservera.h
#ifndef CONCRETESERVERA_H
#define CONCRETESERVERA_H

#include "server.h"

class ConcreteServerA : public Server
{
public:
    virtual void Accept(Visitor *visitor);
};

#endif // CONCRETESERVERA_H

// concreteservera.cpp
#include "concreteservera.h"

void ConcreteServerA::Accept(Visitor *visitor)
{
    this->m_name = "ConcreteServerA ";
    visitor->VisitServerA(this);
}

// concreteserverb.h
#ifndef CONCRETESERVERB_H
#define CONCRETESERVERB_H

#include "server.h"

class ConcreteServerB : public Server
{
public:
    virtual void Accept(Visitor *visitor);
};

#endif // CONCRETESERVERB_H

// concreteserverb.cpp
#include "concreteserverb.h"

void ConcreteServerB::Accept(Visitor *visitor)
{
    this->m_name = "ConcreteServerB";
    visitor->VisitServerB(this);
}

// objectstruct.h
#ifndef OBJECTSTRUCT_H
#define OBJECTSTRUCT_H

#include "visitor.h"
#include "server.h"
#include <vector>

class ObjectStruct
{
public:
    std::vector<Server*> m_serverList;
    void AddServer(Server* server);
    void Run(Visitor* visitor);
};

#endif // OBJECTSTRUCT_H

// objectstruct.cpp
#include "objectstruct.h"

void ObjectStruct::AddServer(Server *server)
{
    m_serverList.push_back(server);
}

void ObjectStruct::Run(Visitor *visitor)
{
    for(std::vector<Server*>::iterator it = m_serverList.begin();
        it != m_serverList.end();
        it++)
    {
        (*it)->Accept(visitor);
    }
}

客户端:

// main.cpp
#include <iostream>
#include "objectstruct.h"
#include "concreteservera.h"
#include "concreteserverb.h"
#include "concretevisitora.h"
#include "concretevisitorb.h"

using namespace std;

int main(int argc, char *argv[])
{
    Server* serverA = new ConcreteServerA();
    Server* serverB = new ConcreteServerB();
    Visitor* visitorA = new ConcreteVisitorA();
    Visitor* visitorB = new ConcreteVisitorB();

    ObjectStruct* objectstruct = new ObjectStruct();
    objectstruct->AddServer(serverA);
    objectstruct->AddServer(serverB);

    objectstruct->Run(visitorA);
    objectstruct->Run(visitorB);

    return 0;
}