Разница между посетителем pattern & Double Dispatch

Короче говоря

Они исходят из различных концептуализаций, которые в некоторых языках, где двойная отправка изначально не поддерживается, приводят к паттерну посетителя как способу объединения двух (или более) одиночных отправлений для того, чтобы иметь многоадресный суррогат.

В длинном

Идея множественной диспетчеризации-по существу-разрешает вызов, подобный

void fn(virtual base_a*, virtual base_b*); (примечание: не как член класса: это не C++! )

Это можно переопределить как

void fn(virtual derived_a1*, virtual derived_b1*);
void fn(virtual derived_a2*, virtual derived_b1*);
void fn(virtual derived_a1*, virtual derived_b2*);
void fn(virtual derived_a2*, virtual derived_b2*);

Так что, при вызове

fn(pa, pb)

Вызов перенаправляется на переопределение, которое соответствует фактическомутипу времени выполнения как pa, так и pb. (Вы можете обобщить это на любое число параметров)

В таких языках, как C++, C#, Java, этот механизм не существует, и диспетчеризация типов среды выполнения в основном работает только с одним параметром (который, будучи только одним, неявно включается в функцию, делая саму функцию членом класс:

Другими словами, псевдокод

void fn(virtual base_a*, base_b*) 

Становится (реальным C++)

class base_a
{
public:
    virtual void fn(base_b*);
}

Обратите внимание, что здесь нет больше virtual перед base_b, что отныне является статичным. Звонок вроде

pa->fn(pb) если pa указывает на derived_a2, а pb на derived_b1 будет отправлено в derived_a2:: fn (base_b*), независимо от того, есть ли там derived_a2::fn(derived_b1*): тип времени выполнения объекта, на который указывает pb, не учитывается.

Идея посетителя Паттер заключается в том, что вы вызываете виртуальную отправку объекта, который вызывает (в конечном итоге) виртуальную отправку другого:

class base_a
{
public:
   virtual void fn(base_b*)=0;
   virtual void on_visit(derived_b1*)=0;
   virtual void on_visit(derived_b2*)=0;
};

class base_b
{
public:
   virtual void on_call(derived_a1*)=0;
   virtual void on_call(derived_a2*)=0;
};

//forward declarations, to allow pointers free use in other decls.
class derived_a1;
class derived_b1;


class derived_a1: public base_a
{
public:
   virtual void fn(base_b* pb) { pb->on_call(this); }
   virtual void on_visit(derived_b1* p1) { /* useful stuff */ }
   ...
};

class derived_b1: public base_b
{
public:
  virtual void on_call(derived_a1* pa1) { pa1->on_visit(this); }
  ... 
};

Теперь вызов типа pa->fn(pb), если pa указывает на derived_a1, а pb-на derived_b1, наконец, перейдет к derived_a1::on_visit(derived_b1*).