能否使用子类的成员函数指针？相关技术实现问题咨询

我明白你现在的困境——明明子类里的函数原型完全一致，但因为是各自独有的，没法直接通过基类指针统一调用，而且你也不想随便修改基类架构。先把你的代码补全成更清晰的示例，方便后续讨论：

class Base {
public:
    Base() {}
    // 基类没有声明子类独有的FunctionA/FunctionB等函数
};

class Child1 : public Base {
public:
    Child1() {}
    void FunctionA(int Arg1, int Arg2) {
        // Child1专属的FunctionA实现
    }
    void FunctionB(int Arg1, int Arg2) {
        // Child1专属的FunctionB实现
    }
};

class Child2 : public Base {
public:
    Child2() {}
    void FunctionA(int Arg1, int Arg2) {
        // Child2专属的FunctionA实现
    }
    void FunctionC(int Arg1, int Arg2) {
        // Child2专属的FunctionC实现
    }
};

结合你的需求，我整理了几个可行的解决方案：

方案1：动态类型转换（dynamic_cast）—— 最直接的临时方案 #

这是不需要修改现有类结构的快速解法，通过运行时类型判断来调用子类函数：

void CallFunctionA(Base* basePtr) {
    // 尝试转换为Child1
    if (Child1* child1Inst = dynamic_cast<Child1*>(basePtr)) {
        child1Inst->FunctionA(10, 20);
    }
    // 尝试转换为Child2
    else if (Child2* child2Inst = dynamic_cast<Child2*>(basePtr)) {
        child2Inst->FunctionA(10, 20);
    }
    // 可以添加默认处理或报错
    else {
        // 处理未知子类的情况
    }
}

优点：零侵入，不需要修改基类或子类的现有代码，快速生效。
缺点：依赖RTTI（运行时类型信息），有轻微性能开销；如果子类数量增多，会出现大量if-else分支，维护性变差。

方案2：访问者模式—— 类型安全的长期方案 #

如果你想摆脱RTTI，同时保持代码的扩展性，可以用访问者模式实现类型安全的函数调用：

首先定义访问者接口，修改基类添加accept方法：

// 访问者基类，声明对每个子类的访问方法
class BaseVisitor {
public:
    virtual void visit(Child1* child1) = 0;
    virtual void visit(Child2* child2) = 0;
};

// 修改基类，添加纯虚accept方法
class Base {
public:
    Base() {}
    virtual void accept(BaseVisitor* visitor) = 0;
};

// 子类实现accept方法，把自己传递给访问者
class Child1 : public Base {
public:
    Child1() {}
    void FunctionA(int Arg1, int Arg2) { /* ... */ }
    void accept(BaseVisitor* visitor) override {
        visitor->visit(this);
    }
};

class Child2 : public Base {
public:
    Child2() {}
    void FunctionA(int Arg1, int Arg2) { /* ... */ }
    void accept(BaseVisitor* visitor) override {
        visitor->visit(this);
    }
};

// 专门调用FunctionA的访问者
class FunctionACaller : public BaseVisitor {
private:
    int arg1_, arg2_;
public:
    FunctionACaller(int a1, int a2) : arg1_(a1), arg2_(a2) {}
    
    void visit(Child1* child1) override {
        child1->FunctionA(arg1_, arg2_);
    }
    
    void visit(Child2* child2) override {
        child2->FunctionA(arg1_, arg2_);
    }
};

使用方式非常简洁：

Base* baseInst = new Child1();
FunctionACaller caller(10, 20);
baseInst->accept(&caller);

优点：类型安全，扩展性好——新增函数只需写新的访问者类，新增子类只需更新访问者接口和子类的accept；完全不依赖RTTI。
缺点：需要修改基类和所有子类，引入额外的类结构，适合长期维护的项目。

方案3：std::variant + std::visit（C17及以上）—— 现代C的轻量方案 #

如果你的项目已经升级到C++17，可以用std::variant存储子类对象，配合std::visit实现无继承的多态调用：

#include <variant>

// 定义存储子类的variant类型
using ChildType = std::variant<Child1, Child2>;

void CallFunctionA(ChildType& childVar) {
    std::visit([](auto& child) {
        // auto会推导为具体的子类类型，直接调用函数
        child.FunctionA(10, 20);
    }, childVar);
}

使用时直接传递variant对象：

ChildType childInst = Child2();
CallFunctionA(childInst);

优点：不需要修改现有类结构，代码简洁优雅；避免了基类指针的内存管理问题（如果用值语义存储）。
缺点：依赖C++17；如果子类数量很多，variant的模板参数会很长；无法处理子类再派生的深层继承场景。

方案4：基类添加纯虚函数—— 最符合OOP的方案（如果允许的话） #

如果这些“独有”函数本质上是基类应该具备的行为（只是不同子类实现不同），那最正统的做法是在基类中声明纯虚函数：

class Base {
public:
    Base() {}
    // 声明纯虚FunctionA，强制子类实现
    virtual void FunctionA(int Arg1, int Arg2) = 0;
    // 如果不是所有子类都有FunctionB，可以给空默认实现
    virtual void FunctionB(int Arg1, int Arg2) {}
};

class Child1 : public Base {
public:
    Child1() {}
    void FunctionA(int Arg1, int Arg2) override { /* ... */ }
    void FunctionB(int Arg1, int Arg2) override { /* ... */ }
};

class Child2 : public Base {
public:
    Child2() {}
    void FunctionA(int Arg1, int Arg2) override { /* ... */ }
    // Child2的FunctionC还是独有，用前面的方案处理即可
    void FunctionC(int Arg1, int Arg2) { /* ... */ }
};

优点：符合面向对象的多态设计，调用最直接，不需要任何类型转换或额外类。
缺点：如果这些函数确实是子类专属的业务逻辑，会污染基类的接口，违背单一职责原则。

你可以根据自己的项目环境、代码维护成本来选择最合适的方案。

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