single dispatch

​ 简单说就是一次虚函数调用

double dispatch

​ 简单说就是两次虚函数调用

为什么要double dispatch

#include <iostream>
#include <typeinfo>
using namespace std;
class Dog;
class Cat;
class Animal {
public:
    virtual void hit(Animal& animal) = 0;
    virtual void hit(Dog& dog) = 0;
    virtual void hit(Cat& cat) = 0;
};
class Dog :public Animal {
    void hit(Animal& animal) override {
        animal.hit(*this);
    }
    void hit(Dog& dog) override {
        cout << "dog hit dog" << endl;
    }
    void hit(Cat& dog) override {
        cout << "dog hit cat" << endl;
    }
};
class Cat :public Animal {
    void hit(Animal& animal) override {
        animal.hit(*this);
    }
    void hit(Dog& dog) {
        cout << "cat hit dog" << endl;
    }
    void hit(Cat& cat) {
        cout << "cat hit cat" << endl;
    }
};
void test1(Animal& cat, Animal& dog) {
    cat.hit(dog); // dog hit cat
}

从编译器看，第一次调用虚函数hit_Animal, 第二次调用虚函数hit_Cat，加上运行时的话，调用的是：

Cat::hit_Animal, Dog::hit_Cat，我以为这样解释方便理解一些。只有double dispatch才能最终调用到Dog::hit_Cat;

visitor parrent:

#include <iostream>
#include <typeinfo>
using namespace std;
class Animal;
class Dog;
class Cat;
class Visitor {
public:
    virtual void hit(Dog& dog) = 0;
    virtual void hit(Cat& cat) = 0;
};
class Animal {
public:
    virtual void accept(Visitor& visitor) = 0;
};
class Dog :public Animal {
public:
    void accept(Visitor& visitor) override {
        visitor.hit(*this);
    }
};
class Cat :public Animal {
public:
    void accept(Visitor& visitor) override {
        visitor.hit(*this);
    }
};
class Visitor1:public Visitor {
public:
    void hit(Dog& dog) override {
        cout << "dog hit dog" << endl;
    }
    void hit(Cat& cat) override {
        cout << "dog hit cat" << endl;
    }
};
void test1(Animal& cat, Animal& dog) {
    Visitor1 v;
    cat.accept(v); // dog hit cat
}

visitor 用于代表动作，

虚函数调用顺序是Cat::accept_Visitor, Visitor1::hit_Cat

上面例子也反映出，如果参数传入函数可能发生了自动类型转换, 以及函数重载解决策略。