如何通过std::any实现C++中的向上转型？

在C++中，基类Base和派生类Derived的向上转型是API设计中的常规操作，但当Derived实例被存储在std::any中时，直接使用std::any_cast<Base>会因为类型ID不匹配返回nullptr，进而导致解引用崩溃。需要在不感知Derived存在的API函数中，从存储Derived的std::any中获取Base指针或引用。

示例代码（会触发段错误）：

#include <any>
#include <iostream>

class Base 
{
public:
    double get_val() const {
        return val;
    }

private: 
    double val {1.23};
};

void normal_function(Base const& b){
    std::cout << b.get_val() << std::endl;
};

void any_function(std::any const& b){
    auto* ptr = std::any_cast<Base>(&b);
    std::cout << ptr->get_val() << std::endl;
}

class Derived : public Base {};

int main()
{
    Derived d;
    
    normal_function(d); // 正常向上转型
    
    std::any ad = d;
    any_function(ad); // 段错误：any_cast返回nullptr
    
    return 0;
}

由于std::any_cast严格匹配类型ID，无法直接支持向上转型，我们可以通过两种可行方式实现需求：

方案1：类型注册+类型擦除（适合反射库场景） #

核心思路是提前为所有需要向上转型到Base的派生类注册转型逻辑，API函数通过类型ID查询并执行转型，无需感知具体派生类。

步骤1：改造基类（推荐） #

给Base添加虚析构函数使其成为多态类，提升后续兼容性（比如支持dynamic_cast）：

class Base 
{
public:
    virtual ~Base() = default; // 标记为多态类
    double get_val() const {
        return val;
    }

private: 
    double val {1.23};
};

步骤2：实现注册与转型逻辑 #

定义全局转型函数表，将派生类类型ID映射到对应的转型函数：

#include <any>
#include <iostream>
#include <typeindex>
#include <unordered_map>
#include <type_traits>

class Base 
{
public:
    virtual ~Base() = default;
    double get_val() const {
        return val;
    }

private: 
    double val {1.23};
};

// 转型函数类型：接收std::any，返回const Base*
using BaseCastFunc = const Base*(*)(const std::any&);
// 全局转型表：类型ID -> 对应转型函数
static std::unordered_map<std::type_index, BaseCastFunc> g_base_cast_table;

// 注册模板函数：仅允许Base的派生类注册
template <typename T>
typename std::enable_if<std::is_base_of<Base, T>::value>::type register_base_cast() {
    g_base_cast_table[std::type_index(typeid(T))] = [](const std::any& a) {
        // 提取std::any中的T实例，安全向上转型为Base指针
        return static_cast<const Base*>(&std::any_cast<const T&>(a));
    };
}

void normal_function(Base const& b){
    std::cout << b.get_val() << std::endl;
};

void any_function(std::any const& b){
    std::type_index type_idx(b.type());
    auto it = g_base_cast_table.find(type_idx);
    if (it != g_base_cast_table.end()) {
        const Base* ptr = it->second(b);
        std::cout << ptr->get_val() << std::endl;
    } else {
        std::cerr << "错误：未注册的类型，无法转型到Base" << std::endl;
    }
}

class Derived : public Base {};

// 显式注册Derived类型（确保编译时实例化模板）
template void register_base_cast<Derived>();

int main()
{
    // 注册所有需要支持转型的派生类
    register_base_cast<Derived>();

    Derived d;
    
    normal_function(d);

    std::any ad = d;
    any_function(ad); // 正常输出1.23
    
    return 0;
}

方案2：提前存储引用包装（简洁版） #

如果允许在存储到std::any时主动进行向上转型，可以使用std::reference_wrapper直接存储Base的引用，让std::any_cast直接匹配类型：

#include <any>
#include <iostream>
#include <functional>

class Base 
{
public:
    double get_val() const {
        return val;
    }

private: 
    double val {1.23};
};

void normal_function(Base const& b){
    std::cout << b.get_val() << std::endl;
};

void any_function(std::any const& b){
    if (auto base_ref = std::any_cast<std::reference_wrapper<const Base>>(&b)) {
        std::cout << base_ref->get().get_val() << std::endl;
    } else {
        std::cerr << "错误：std::any中存储的不是Base引用" << std::endl;
    }
}

class Derived : public Base {};

int main()
{
    Derived d;
    
    normal_function(d);

    // 存储时先向上转型为Base引用，用reference_wrapper包装
    std::any ad = std::cref(static_cast<const Base&>(d));
    any_function(ad); // 正常输出1.23
    
    return 0;
}

• 类型注册方案适合反射库场景：无需修改存储逻辑，仅需在派生类定义后注册，API函数完全不感知具体派生类。
• 引用包装方案更简洁，但需要在存储std::any时主动触发向上转型，适合对存储流程有控制权的场景。

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