C++：调用参数为同一基类派生类的重载虚方法优化问询

嘿，你碰到的是C里典型的双分派问题——毕竟C的虚函数默认只做单分派（只看调用者的动态类型），但你需要同时根据Floor和Object的具体派生类来匹配对应的Enter方法，确实得动点脑筋。

先聊聊你现在的实现：通过在Floor子类构造时初始化成员函数指针，把对应重载的Enter转成基类指针，最后用(o->*(f->enter))(f)完成调用，这个思路是能跑通的，但手动的类型转换有点不安全，而且以后加新的Floor子类时，每次都要重复处理指针转换，容易漏错。

下面给你介绍更贴合C++面向对象风格的双分派实现，完全不用手动搞函数指针和类型转换，扩展性也更好：

标准双分派的核心思路 #

说白了就是用两次单分派凑成双分派：

1. 给Floor基类加个虚方法Accept，参数是Object*，这个方法会调用传入对象的Enter，把this传进去；
2. 每个Floor子类都重写Accept，调用对应重载的Enter（也就是把this转成子类类型传给Object的Enter）；
3. 触发逻辑时只需要调用f->Accept(o)，就能自动匹配到两个派生类对应的Enter方法。

完整可运行代码 #

#include <iostream>
using namespace std;

// 前向声明
class Floor;
class Flagstone;
class GrassFloor; // 加个新的Floor子类测试扩展性

class Object {
public:
    // 对应不同Floor子类的Enter重载
    virtual void Enter(Floor *f);
    virtual void Enter(Flagstone *fs);
    virtual void Enter(GrassFloor *gf);
};

class Box : public Object {
public:
    void Enter(Floor *f) override;
    void Enter(Flagstone *fs) override;
    void Enter(GrassFloor *gf) override;
};

class Floor {
public:
    // 虚Accept方法，负责触发双分派
    virtual void Accept(Object *o) = 0;
};

class Flagstone : public Floor {
public:
    void Accept(Object *o) override {
        // 这里的this是Flagstone*，会调用Object（或子类）的Enter(Flagstone*)
        o->Enter(this);
    }
};

class GrassFloor : public Floor {
public:
    void Accept(Object *o) override {
        o->Enter(this);
    }
};

// Object类的Enter实现
void Object::Enter(Floor *f) {
    cout << "通用对象进入通用地板" << endl;
}

void Object::Enter(Flagstone *fs) {
    cout << "通用对象进入石板地板" << endl;
}

void Object::Enter(GrassFloor *gf) {
    cout << "通用对象进入草地地板" << endl;
}

// Box类的Enter实现
void Box::Enter(Floor *f) {
    cout << "Box进入通用地板" << endl;
}

void Box::Enter(Flagstone *fs) {
    cout << "Box进入石板地板" << endl;
}

void Box::Enter(GrassFloor *gf) {
    cout << "Box进入草地地板" << endl;
}

int main() {
    Floor *f1 = new Flagstone();
    Floor *f2 = new GrassFloor();
    Object *o1 = new Object();
    Object *o2 = new Box();

    // 一次调用就搞定双分派
    f1->Accept(o1); // 输出：通用对象进入石板地板
    f1->Accept(o2); // 输出：Box进入石板地板
    f2->Accept(o1); // 输出：通用对象进入草地地板
    f2->Accept(o2); // 输出：Box进入草地地板

    // 记得清理内存
    delete f1;
    delete f2;
    delete o1;
    delete o2;
    return 0;
}

两种方案对比 #

• 你的现有实现：好处是调用写法直接，但手动类型转换有安全隐患，新增Floor子类时必须重复指针转换逻辑，维护成本高；
• 标准双分派方案：完全依赖C++虚函数机制，类型安全，扩展性强（加新的Floor或Object子类时，只需要加对应的Accept或Enter重载就行），代码可读性也更高，是这类场景的标准解法。

额外提一句 #

如果你的类族以后会频繁扩展，还可以试试访问者模式——其实访问者模式的核心就是双分派，和上面的思路本质一样，只是命名和结构更规范，适合复杂的类族场景。

内容的提问来源于stack exchange，提问作者RobertSzacki