C++ 中实现动态任意类型转换指针的探讨
来源标题:Dynamic Any-Casting in C++
有开发者探讨如何在 C++ 中实现可动态转换的"any"指针,使其能指向任意类型 T 并按原始类型是否实现某接口进行转换。文章指出使用 Object 父类虽可借助 dynamic_cast 实现转换,但要求 T 继承自 Object,无法满足指向任意类型的需求,并认为这在 C++ 中是棘手问题。
以下正文由 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 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。