返回资讯中心
外部精选
软件工程
#开发者实时流

C++ 中实现动态任意类型转换指针的探讨

来源标题:Dynamic Any-Casting in C++

有开发者探讨如何在 C++ 中实现可动态转换的"any"指针,使其能指向任意类型 T 并按原始类型是否实现某接口进行转换。文章指出使用 Object 父类虽可借助 dynamic_cast 实现转换,但要求 T 继承自 Object,无法满足指向任意类型的需求,并认为这在 C++ 中是棘手问题。

Hacker News 最新nicbn2026/11/18 · 今天17 分钟阅读

以下正文由 AI 翻译自 Hacker News 最新(原文版权归原站所有),可能存在偏差,重要内容请以原文为准。

前阵子我和同事聊天,最后讨论到如何在 C++ 中实现一个可动态转换的 “any” 指针。规则是:

你可以想想 Go 里的 any 类型,以及如何把它转换成接口 U——如果原始值 T 实现了 U 的话。事实证明这在 C++ 里是个棘手的问题。

如果我们用一个超类型,这看起来很简单。

class Object {
public:
    virtual ~Object() = default;
};

#include <cstdio>
#include <memory>

class MyBaseClass : public Object {};
class MyDerivedClass : public MyBaseClass {};
class UnrelatedClass : public Object {};

int main()
{
    std::unique_ptr<Object> any_pointer = std::make_unique<MyDerivedClass>();
    MyDerivedClass *derived = dynamic_cast<MyDerivedClass *>(any_pointer.get());
    MyBaseClass *base = dynamic_cast<MyBaseClass *>(any_pointer.get());
    // 返回 nullptr:
    UnrelatedClass *unrelated = dynamic_cast<UnrelatedClass *>(any_pointer.get());
    std::printf("%p %p %p\n", derived, base, unrelated);
    return 0;
}

然而,这违背了第一条要求:

你可以用 “any” 指针指向任意类型 T

我们无法指向任意类型 T,因为我们要求 T : public Object。由于语言层面并不支持一个全局超类型,所以这个方案不是我们想要的。

为了探索更多方案,我们先搭一个小框架。整体思路是创建一个类型 any,它是一个 unique 指针(类似 std::unique_ptr),指向我们自定义的类型。不过,为了能在被指向的值内部实现操作,我们会用另一个类型把它包起来,这个类型叫 any_impl<T>,它继承自 any_base。

#include <memory>

class any_base {
public:
    virtual ~any_base() = default;
    // 自定义方法
};

template <typename T>
class any_impl final : public any_base {
public:
    template <typename... Args>
    any_impl(Args &&...args) : m_value{std::forward<T>(args)...}
    ~any_impl() override = default;
    // 自定义实现
private:
    T m_value;
};

class any final {
public:
    template <class ValueType, class... Args>
    explicit any(std::in_place_type_t<ValueType>, Args &&...args)
        : m_ptr{std::make_unique<any_impl<ValueType>>(
              std::forward<Args>(args)...)}
    {}
private:
    std::unique_ptr<any_base> m_ptr;
};

template <class T, class... Args>
any make_any(Args &&...args)
{
    return any(std::in_place_type<T>, std::forward<Args>(args)...);
}

只有 any 需要是公开的,这意味着我们可以把 any_base 和 any_impl 移到 class any 的 private 区里。不过为了演示方便,我还是把它们分开写。

如果我们先检查 typeid,再转换成 void *,然后用 reinterpret_cast 呢?

#include <memory>
#include <typeinfo>

class any_base {
public:
    virtual ~any_base() = default;
    virtual void *cast(const std::type_info &ty) = 0;
};

template <typename T>
class any_impl final : public any_base {
public:
    template <typename... Args>
    any_impl(Args &&...args) : m_value{std::forward<T>(args)...}
    ~any_impl() override = default;

    void *cast(const std::type_info &ty) override
    {
        if (ty == typeid(T)) {
            return static_cast<void *>(&m_value);
        }
        return nullptr;
    }
private:
    T m_value;
};

class any final {
public:
    template <class ValueType, class... Args>
    explicit any(std::in_place_type_t<ValueType>, Args &&...args)
        : m_ptr{std::make_unique<any_impl<ValueType>>(
              std::forward<Args>(args)...)}
    {}

    template <typename T>
    T *cast()
    {
        return reinterpret_cast<T *>(m_ptr->cast(typeid(T)));
    }
private:
    std::unique_ptr<any_base> m_ptr;
};

template <class T, class... Args>
any make_any(Args &&...args)
{
    return any(std::in_place_type<T>, std::forward<Args>(args)...);
}

如你所料,这对 T 的超类型 U 不管用:

#include <cstdio>

class MyBaseClass {};
class MyDerivedClass : public MyBaseClass {};
class UnrelatedClass {};

int main()
{
    any any_pointer = make_any<MyDerivedClass>();
    // 有效
    MyDerivedClass *derived = any_pointer.cast<MyDerivedClass>();
    // 无效
    MyBaseClass *base = any_pointer.cast<MyBaseClass>();
    std::printf("%p %p\n", derived, base);
    return 0;
}

如果你只需要转换到叶子类,std::any 也已经为你做到了。

据我所知,这只有借助反射才能实现。如果你想解开这个谜题并了解反射语法,我建议你暂停阅读,自己试一试!

整体思路是:在 any_impl<T> 中,cast(const std::type_info& ty) 会拿 ty 与 typeid(T) 比较,并递归地与 T 的每一个基类的 typeid(U) 比较。

#include <memory>
#include <meta>
#include <type_traits>
#include <typeinfo>

class any_base {
public:
    virtual ~any_base() = default;
    virtual void *cast(const std::type_info &ty) = 0;
};

template <typename T>
class any_impl final : public any_base {
public:
    template <typename... Args>
    any_impl(Args &&...args) : m_value{std::forward<T>(args)...}
    ~any_impl() override = default;

    void *cast(const std::type_info &ty) override
    {
        if (is_derived_from_type_info<T>(ty)) {
            return static_cast<void *>(&m_value);
        }
        return nullptr;
    }
private:
    template <typename Derived>
    static bool is_derived_from_type_info(const std::type_info &ty)
    {
        if (ty == typeid(Derived)) {
            return true;
        }
        if constexpr (std::is_class_v<Derived>) {
            template for (constexpr auto base :
                std::define_static_array(std::meta::bases_of(
                    ^^Derived,
                    std::meta::access_context::current())))
            {
                constexpr auto base_ty = std::meta::type_of(base);
                if (is_derived_from_type_info<typename[:base_ty:]>(ty)) {
                    return true;
                }
            }
        }
        return false;
    }
    T m_value;
};

class any final {
public:
    template <class ValueType, class... Args>
    explicit any(std::in_place_type_t<ValueType>, Args &&...args)
        : m_ptr{std::make_unique<any_impl<ValueType>>(
              std::forward<Args>(args)...)}
    {}

    template <typename T>
    T *cast()
    {
        return reinterpret_cast<T *>(m_ptr->cast(typeid(T)));
    }
private:
    std::unique_ptr<any_base> m_ptr;
};

template <class T, class... Args>
any make_any(Args &&...args)
{
    return any(std::in_place_type<T>, std::forward<Args>(args)...);
}

#include <cstdio>

struct MyBaseClass {};
struct MyDerivedClass : public MyBaseClass {};

(原文较长,此处译出前 6000 字,完整内容请点「打开原文」。)

正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。

打开原文
去社区讨论 →