为什么我们需要在访问者模式中的接受（），为什么我们不能直接调用visitor.visit（）？

Question

我正在修改我以前使用的Visitor模式。我们有基类Element，它有虚拟方法接受（Visitor），并且这个方法在继承自Element的所有类中都被重写。在任何派生类中，接受（）所做的就是调用visitor-

Visitor& theVisitor = *new ConcreteVisitor();    
for_each(elements.begin(), elements.end(), [](Element& e) { e.accept(theVisitor));})

为什么客户不能直接打电话给访客-

Visitor& theVisitor = *new ConcreteVisitor();    
for_each(elements.begin(), elements.end(), [&theVisitor](Element& e) { theVisitor.visit(e); });

调用元素中有哪些有用的信息。接受（访客），然后依次呼叫访客。参观（元素）？这使得Visitor模式的使用很麻烦，并且在所有元素类的层次结构中都需要额外的代码。

有人能在这里解释一下accept（）的好处吗？

Answer 1

我一直对访客模式感到困惑，我一直试图在互联网上找到解释，这些解释让我更加困惑。现在我意识到为什么需要访客模式以及它是如何实现的，所以这里是：

需要采用访客模式来解决双重调度问题。

单一分派-当你有一个类层次结构，并且在这个层次结构中有一个具体类的实例，并且你想为这个实例调用一个合适的方法。这是通过函数重写（在C中使用虚拟函数表）来解决的。

双重分派是指当您有两个类层次结构，一个层次结构中有一个具体类实例，另一个层次结构中有一个具体类实例，并且您希望调用适当的方法来完成这两个特定实例的工作。

我们来看一个例子。

第一等级：动物。基础：动物，衍生：鱼，哺乳动物，鸟。第二类层次结构：调用程序。基础：Invoker，派生：MovementInvoker（移动动物）、VoiceInvoker（使动物发声）、FeedingInvoker（喂养动物）。

现在，对于每个特定的动物和每个特定的调用程序，我们只希望调用一个特定的函数来完成特定的工作（例如喂鸟或给鱼发声）。所以我们总共有3x3=9个函数来做这些工作。

另一件重要的事：运行这9个函数的客户机不想知道他或她手头上有什么具体的动物，以及什么具体的调用程序。

因此，客户想要做如下事情：

void act(Animal& animal, Invoker& invoker)
{
  // Do the job for this specific animal using this specific invoker
}

或者：

void act(vector<shared_ptr<Animal>>& animals, vector<shared_ptr<Invoker>>& invokers)
{
    for(auto& animal : animals)
    {
        for(auto& invoker : invokers)
        {
            // Do the job for this specific animal and invoker.
        }
    }
}

现在：如何在运行时调用9个（或任何）特定方法中的一个，来处理这个特定的动物和这个特定的调用程序？

这是双重调度。您绝对需要从第一类层次结构中调用一个虚拟函数，从第二类层次结构中调用一个虚拟函数。

因此，您需要调用Animal的虚拟方法（使用虚拟函数表，这将在Animal类层次结构中找到具体实例的具体函数），还需要调用Invoker的虚拟方法（这将找到具体的Invoker）。

你必须称之为两种虚拟方法。

下面是实现（您可以复制并运行，我用g编译器对其进行了测试）：

来访者h:

#ifndef __VISITOR__
#define __VISITOR__

struct Invoker; // forward declaration;

// -----------------------------------------//

struct Animal
{
    // The name of the function can be anything of course.
    virtual void accept(Invoker& invoker) = 0;
};

struct Fish : public Animal
{
    void accept(Invoker& invoker) override;
};

struct Mammal : public Animal
{
    void accept(Invoker& invoker) override;
};

struct Bird : public Animal
{
    void accept(Invoker& invoker) override;
};

// -----------------------------------------//

struct Invoker
{
  virtual void doTheJob(Fish&   fish)   = 0;
  virtual void doTheJob(Mammal& Mammal) = 0;
  virtual void doTheJob(Bird&   Bird)   = 0;
};

struct MovementInvoker : public Invoker
{
  void doTheJob(Fish&   fish)   override;
  void doTheJob(Mammal& Mammal) override;
  void doTheJob(Bird&   Bird)   override;
};

struct VoiceInvoker : public Invoker
{
  void doTheJob(Fish&   fish)   override;
  void doTheJob(Mammal& Mammal) override;
  void doTheJob(Bird&   Bird)   override;
};

struct FeedingInvoker : public Invoker
{
  void doTheJob(Fish&   fish)   override;
  void doTheJob(Mammal& Mammal) override;
  void doTheJob(Bird&   Bird)   override;
};

#endif

visitor.cpp：

#include <iostream>
#include <memory>
#include <vector>
#include "visitor.h"
using namespace std;

// -----------------------------------------//

void Fish::accept(Invoker& invoker)
{
    invoker.doTheJob(*this);
}

void Mammal::accept(Invoker& invoker)
{
    invoker.doTheJob(*this);
}

void Bird::accept(Invoker& invoker)
{
    invoker.doTheJob(*this);
}

// -----------------------------------------//

void MovementInvoker::doTheJob(Fish& fish)
{
    cout << "Make the fish swim" << endl;
}

void MovementInvoker::doTheJob(Mammal& Mammal)
{
    cout << "Make the mammal run" << endl;
}

void MovementInvoker::doTheJob(Bird& Bird)
{
    cout << "Make the bird fly" << endl;
}

// -----------------------------------------//

void VoiceInvoker::doTheJob(Fish& fish)
{
    cout << "Make the fish keep silence" << endl;
}

void VoiceInvoker::doTheJob(Mammal& Mammal)
{
    cout << "Make the mammal howl" << endl;
}

void VoiceInvoker::doTheJob(Bird& Bird)
{
    cout << "Make the bird chirp" << endl;
}

// -----------------------------------------//

void FeedingInvoker::doTheJob(Fish& fish)
{
    cout << "Give the fish some worms" << endl;
}

void FeedingInvoker::doTheJob(Mammal& Mammal)
{
    cout << "Give the mammal some milk" << endl;
}

void FeedingInvoker::doTheJob(Bird& Bird)
{
    cout << "Give the bird some seed" << endl;
}

int main()
{
    vector<shared_ptr<Animal>> animals = { make_shared<Fish>   (),
                                           make_shared<Mammal> (),
                                           make_shared<Bird>   () };

    vector<shared_ptr<Invoker>> invokers = { make_shared<MovementInvoker> (),
                                             make_shared<VoiceInvoker>    (),
                                             make_shared<FeedingInvoker>  () };

    for(auto& animal : animals)
    {
        for(auto& invoker : invokers)
        {
            animal->accept(*invoker);
        }
    }
}

上述代码的输出：

Make the fish swim
Make the fish keep silence
Give the fish some worms
Make the mammal run
Make the mammal howl
Give the mammal some milk
Make the bird fly
Make the bird chirp
Give the bird some seed

那么，当客户端获得Animal的实例和Invoker的实例并调用Animal时会发生什么呢。接受（调用者）？

假设Animal的实例是Bird，Invoker的实例是FeedingInvoker。

然后感谢虚拟函数表Bird:：accept（调用程序

因此，我们进行了双重调度，并为Bird和FeedingInvoker调用了正确的方法（9种可能的方法之一）。

为什么访客模式好？

>

客户端不需要同时依赖于动物和调用者的复杂类层次结构。

如果需要添加新的具体动物（例如，昆虫），则不需要更改现有的动物层次结构。我们只需要添加：doTheJob（昆虫）

Visitor模式优雅地实现了面向对象设计的开放/封闭原则：系统应该对扩展开放，对修改关闭。

（在经典的访问者模式中，Invoker将被Visitor取代，doTheJob（）将被visit（）取代，但对我来说，这些名称实际上并不反映某些工作是在元素上完成的）。