设计模式之访问模式

优点：没看懂。如图，可以通过基类A， 派生出两个基类。而派生类的对象可以通过B的父子类关系，来访问B的派生类里的接口。

 

 

#pragma once

class ConcreateElementA;

class ConcreateElementB;

class Element;

class Visitor
{
public:
    ~Visitor();

    virtual void VisitConcreateElementA(Element *elm) = 0;

    virtual void VisitConcreateElementB(Element *lem) = 0;

protected:
    Visitor();
};

#include "Visitor.h"


Visitor::Visitor()
{
}


Visitor::~Visitor()
{
}

 

 

#pragma once

class Visitor;

class Element
{
public:
    virtual ~Element();

    virtual void Accept(Visitor *vis) = 0;

protected:
    Element();
};

#include "Element.h"


Element::Element()
{
}


Element::~Element()
{
}

 

#pragma once
#include "Element.h"
class ConcreateElementA :
    public Element
{
public:
    ConcreateElementA();

    ~ConcreateElementA();

    void Accept(Visitor *vis);
};

#include "ConcreateElementA.h"
#include "ConcreateVisitorA.h"
#include "ConcreateVisitorB.h"
#include <iostream>



ConcreateElementA::ConcreateElementA()
{
}


ConcreateElementA::~ConcreateElementA()
{
}

void ConcreateElementA::Accept(Visitor *vis)
{
    vis->VisitConcreateElementA(this);
    std::cout << "visiting ConcreateElementA..." << std::endl;
    return;
}

 

#pragma once
#include "Element.h"

class Visitor;

class ConcreateElementB :
    public Element
{
public:
    ConcreateElementB();

    ~ConcreateElementB();

    void Accept(Visitor *vis);
};

#include "ConcreateElementB.h"
#include "ConcreateVisitorA.h"
#include "ConcreateVisitorB.h"
#include <iostream>


ConcreateElementB::ConcreateElementB()
{
}


ConcreateElementB::~ConcreateElementB()
{
}

void ConcreateElementB::Accept(Visitor *vis)
{
    vis->VisitConcreateElementB(this);
    std::cout << "visting ConcreateElementB..." << std::endl;
    return;
}

 

为什么要把Visitor的派生放在后面，是为了方便理解。

#pragma once
#include "Visitor.h"
class ConcreateVisitorA :
    public Visitor
{
public:
    ConcreateVisitorA();

    virtual ~ConcreateVisitorA();

    virtual void VisitConcreateElementA(Element *elm);

    virtual void VisitConcreateElementB(Element *lem);
};

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


ConcreateVisitorA::ConcreateVisitorA()
{
}


ConcreateVisitorA::~ConcreateVisitorA()
{
}

void ConcreateVisitorA::VisitConcreateElementA(Element *elm)
{
    std::cout << "i will visit ConcreateVisitorA::ConcreateElementA..." << std::endl;
    return;
}

void ConcreateVisitorA::VisitConcreateElementB(Element *lem)
{
    std::cout << "i will visit ConcreateVisitorA::ConcreateElementB..." << std::endl;
    return;
}

 

#pragma once
#include "Visitor.h"
class ConcreateVisitorB :
    public Visitor
{
public:
    ConcreateVisitorB();

    virtual ~ConcreateVisitorB();

    virtual void VisitConcreateElementA(Element *elm);

    virtual void VisitConcreateElementB(Element *lem);
};

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

ConcreateVisitorB::ConcreateVisitorB()
{
}


ConcreateVisitorB::~ConcreateVisitorB()
{
}

void ConcreateVisitorB::VisitConcreateElementA(Element *elm)
{
    std::cout << "i will visit ConcreateVisitorB::ConcreateElementA..." << std::endl;
    return;
}

void ConcreateVisitorB::VisitConcreateElementB(Element *lem)
{
    std::cout << "i will visit ConcreateVisitorB::ConcreateElementB..." << std::endl;
    return;
}

 

测试

#include <iostream>
#include "ConcreateElementA.h"
#include "ConcreateElementB.h"
#include "ConcreateVisitorA.h"
#include "ConcreateVisitorB.h"

int main()
{
    Visitor *vis = new ConcreateVisitorA();

    Element *elm = new ConcreateElementA();

    elm->Accept(vis);

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

    if (vis)
    {
        delete vis;
        vis = NULL;
    }
    std::cout << "Hello World!\n"; 
}