C++虚函数重载遇编译错误，求替代std::any的解决方案

问题根源 #

基类引用/指针只能访问基类中声明过的成员函数，派生类新增的show(std::string)不在基类的虚函数表中，编译阶段编译器会优先匹配基类的show(int)，导致类型转换错误。下面是几种无需在基类逐个添加纯虚函数的可行方案：

方案1：访客模式（Visitor Pattern） #

适合需要对多个派生类执行多种操作的场景，核心是将操作从类中剥离，通过访客类统一处理不同派生类的特定函数调用。

#include <string>
#include <iostream>

// 前向声明派生类
class Derived;

// 访客接口
class Visitor {
public:
    virtual void visit(const Derived& obj, const std::string& s) = 0;
    virtual void visit(const Derived& obj, int i) = 0;
    // 新增派生类时，只需扩展Visitor接口和实现
};

// 基类
class Base {
public:
    virtual void accept(Visitor& visitor) const = 0;
    virtual void show(int i) const {
        std::cout << "Base show(int): " << i << std::endl;
    }
};

// 派生类
class Derived : public Base {
public:
    using Base::show; // 引入基类的show(int)
    void show(const std::string& s) const {
        std::cout << "Derived show(string): " << s << std::endl;
    }

    void accept(Visitor& visitor) const override {
        // 可根据实际调用需求传递参数
        visitor.visit(*this, "hello");
    }
};

// 具体访客实现
class ShowVisitor : public Visitor {
public:
    void visit(const Derived& obj, const std::string& s) const override {
        obj.show(s);
    }

    void visit(const Derived& obj, int i) const override {
        obj.show(i);
    }
};

// 使用示例
int main() {
    Derived d;
    Base& b = d;
    ShowVisitor visitor;
    
    // 通过访客调用派生类的show(string)
    visitor.visit(static_cast<const Derived&>(b), "hello");
    // 调用基类的show(int)
    b.show(123);
    return 0;
}

优势：基类无需修改，新增派生类或操作时只需扩展访客类，符合开闭原则。

方案2：CRTP（奇异递归模板模式）结合动态多态 #

利用CRTP实现静态转发，同时保留基类的动态多态特性，适合编译期能部分确定类型、且想减少虚函数数量的场景。

#include <string>
#include <iostream>
#include <utility>

// CRTP基类，提供转发能力
template<typename Derived>
class CRTPBase {
public:
    template<typename T>
    void show(T&& val) {
        static_cast<Derived*>(this)->show(std::forward<T>(val));
    }
};

// 实际基类，继承CRTPBase并保留动态多态
class Base : public CRTPBase<Base> {
public:
    virtual void show(int i) {
        std::cout << "Base show(int): " << i << std::endl;
    }
    virtual ~Base() = default;
};

// 派生类
class Derived : public CRTPBase<Derived>, public Base {
public:
    using Base::show; // 引入基类的show(int)
    void show(const std::string& s) {
        std::cout << "Derived show(string): " << s << std::endl;
    }

    // 重写基类的show(int)（可选）
    void show(int i) override {
        std::cout << "Derived show(int): " << i << std::endl;
    }
};

// 使用示例
int main() {
    Derived d;
    Base* b = &d;

    // 通过CRTP的模板函数转发到派生类的show(string)
    if(auto derived_ptr = dynamic_cast<CRTPBase<Derived>*>(b)){
        derived_ptr->show("hello");
    }
    // 调用动态多态的show(int)
    b->show(123);
    return 0;
}

注意：需要通过dynamic_cast安全转换基类指针到CRTP子类指针，避免类型错误。

方案3：std::variant + 重载访问 #

如果需要支持的参数类型有限，可以在基类定义一个接受std::variant的虚函数，派生类通过std::visit调用对应的重载函数。

#include <string>
#include <iostream>
#include <variant>
#include <functional>

using ShowArg = std::variant<int, std::string>;

class Base {
public:
    virtual void show(ShowArg arg) = 0;
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void show(int i) {
        std::cout << "Derived show(int): " << i << std::endl;
    }

    void show(const std::string& s) {
        std::cout << "Derived show(string): " << s << std::endl;
    }

    void show(ShowArg arg) override {
        std::visit([this](auto&& val) {
            this->show(std::forward<decltype(val)>(val));
        }, arg);
    }
};

// 使用示例
int main() {
    Derived d;
    Base& b = d;

    b.show(std::string("hello"));
    b.show(123);
    return 0;
}

优势：基类只需一个虚函数，派生类可以自由扩展支持的ShowArg类型（只需添加到variant中并实现对应的重载）。

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