C++ Double Dispatch，即双重调度
调度概述
对于初次接触或曾有所闻但未曾深入了解的开发人员而言，调度（Dispatching）这一概念值得我们深入探讨。调度，从字面意义上理解，即将某物发送至特定目的地。在C++编程中，调度同样指将控制权从一处转移至另一处，例如从主方法调用函数或方法时，程序会跳转至新的地址空间并执行该方法。这一过程即称为调度。
根据方法调用的性质，调度可分为静态调度（Static Dispatch）和动态调度（Dynamic Dispatch）。静态调度在编译时确定调用的函数，这种方式没有运行时开销，因为编译器在编译阶段就能确定应该调用哪个函数。相反，动态调度则在运行时确定调用的函数，这为程序提供了灵活性，允许程序根据对象的实际类型在运行时决定调用哪个函数，从而支持多态性。
在字面上，静态调度和动态调度均属于单重调度（Single Dispatch），即调度机制仅依赖于单个对象的类型来决定调用的函数。
双重调度解析
在理解了单重调度的基础上，我们进一步探讨双重调度（Double Dispatch）。双重调度意味着调度机制依赖于两个对象的类型来决定调用的函数。然而，需要注意的是，C++语言本身并不直接支持双重调度。
以下是一个尝试通过虚函数实现双重调度的示例代码：
class Bird {};
class Chicken : public Bird {};
class Animal {
public:
virtual void eats(Bird *b) {
cout << "Animal Eats Bird" << endl;
}
virtual void eats(Chicken *b) {
cout << "Animal Eats Chicken" << endl;
}
};
class Tiger : public Animal {
public:
void eats(Bird *b) {
cout << "Tiger Eats Bird" << endl;
}
void eats(Chicken *b) {
cout << "Tiger Eats Chicken" << endl;
}
};
int main() {
Animal *tiger = new Tiger();
Bird *chicken = new Chicken();
tiger->eats(chicken); // 输出结果并非预期的 "Tiger Eats Chicken"
return 0;
}
在上述代码中，我们期望的输出结果是“Tiger Eats Chicken”，然而实际上编译器输出的结果是“Tiger Eats Bird”。原因在于C++仅支持单重调度，即仅根据Animal指针（指向Tiger对象）来确定调用的eats方法，而未能根据Bird指针（指向Chicken对象）进行第二次调度。
尽管C++语言本身不支持双重调度，但我们可以通过其他方式（如访问者模式）来模拟实现双重调度的效果。这些模式允许我们在运行时根据两个对象的类型来决定调用的方法，从而在一定程度上实现双重调度的功能。
使用访问者模式模拟双重调度的示例代码：
#include <iostream>
#include <memory>
#include <vector>
// 基类接口，定义接受访问者的方法
class Visitable {
public:
virtual ~Visitable() {}
virtual void accept(std::shared_ptr<class Visitor> visitor) = 0;
};
// 具体的可访问对象
class Bird : public Visitable {
public:
void accept(std::shared_ptr<class Visitor> visitor) override {
visitor->visit(std::static_pointer_cast<Bird>(shared_from_this()));
}
// 其他Bird相关的方法...
};
class Chicken : public Visitable {
public:
void accept(std::shared_ptr<class Visitor> visitor) override {
visitor->visit(std::static_pointer_cast<Chicken>(shared_from_this()));
}
// 其他Chicken相关的方法...
};
// 访问者接口，定义访问不同对象的方法
class Visitor {
public:
virtual ~Visitor() {}
virtual void visit(std::shared_ptr<Bird> bird) = 0;
virtual void visit(std::shared_ptr<Chicken> chicken) = 0;
};
// 具体的访问者，实现访问不同对象时的行为
class AnimalVisitor : public Visitor {
public:
void visit(std::shared_ptr<Bird> bird) override {
std::cout << "Animal visits Bird" << std::endl;
}
void visit(std::shared_ptr<Chicken> chicken) override {
std::cout << "Animal visits Chicken" << std::endl;
}
};
class TigerVisitor : public Visitor {
public:
void visit(std::shared_ptr<Bird> bird) override {
std::cout << "Tiger eats Bird" << std::endl;
}
void visit(std::shared_ptr<Chicken> chicken) override {
std::cout << "Tiger eats Chicken" << std::endl;
}
};
int main() {
// 创建可访问对象
std::shared_ptr<Bird> bird = std::make_shared<Bird>();
std::shared_ptr<Chicken> chicken = std::make_shared<Chicken>();
// 创建访问者
std::shared_ptr<Visitor> animalVisitor = std::make_shared<AnimalVisitor>();
std::shared_ptr<Visitor> tigerVisitor = std::make_shared<TigerVisitor>();
// 使用访问者访问对象，模拟双重调度
bird->accept(animalVisitor); // 输出: Animal visits Bird
chicken->accept(animalVisitor); // 输出: Animal visits Chicken
bird->accept(tigerVisitor); // 输出: Tiger eats Bird
chicken->accept(tigerVisitor); // 输出: Tiger eats Chicken
return 0;
} 在这个例子中，Visitable是一个接口，定义了accept方法，该方法接受一个Visitor对象。Bird和Chicken类实现了Visitable接口，并在accept方法中调用访问者的visit方法，同时将自身（通过std::static_pointer_cast转换为正确的类型）作为参数传递。
Visitor是一个接口，定义了访问Bird和Chicken对象的方法。AnimalVisitor和TigerVisitor是具体的访问者类，它们实现了Visitor接口，并在visit方法中定义了访问不同对象时的行为。
在main函数中，我们创建了Bird和Chicken对象，以及AnimalVisitor和TigerVisitor访问者。通过调用accept方法，我们将访问者传递给可访问对象，从而模拟了双重调度的效果。根据访问者和被访问对象的类型，程序会输出相应的结果。
原文地址：https://blog.csdn.net/weixin_42215453/article/details/143625718
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！