自定义std::get处理继承std::tuple的Tuple类遇编译错误求助

我创建了一个继承自std::tuple的Tuple类，核心逻辑是将传入的模板参数全部包装为std::optional后作为基类。相关实现代码如下：

template<class, class>
struct tuple_prepend;

template<class T, class ...Ts>
struct tuple_prepend<T, std::tuple<Ts...>>
{
    using type = std::tuple<T, Ts...>;
};

template<class ...Ts>
struct tuple_optional_impl;

template<class T, class ...Ts>
struct tuple_optional_impl<T, Ts...>
{
    using type = typename tuple_prepend<std::optional<T>, typename tuple_optional_impl<Ts...>::type>::type;
};

template<class T>
struct tuple_optional_impl<T>
{
    using type = std::tuple<std::optional<T>>;
};

template<class ...Ts>
struct tuple_optional;

template<class ...Ts>
struct tuple_optional<std::tuple<Ts...>>
{
    using type = typename tuple_optional_impl<Ts...>::type;
};

template<class ...Ts>
class Tuple : public tuple_optional<std::tuple<Ts...>>::type
{
};

我需要为Tuple类实现自定义的std::get<T>，写出了如下代码：

namespace std
{
    template<class T, class ...Ts>
    std::optional<T> get(Tuple<Ts...> &_tuple) noexcept
    {
        return std::get<std::optional<T>>(static_cast<tuple_optional<std::tuple<Ts...>>::type>(_tuple));
    }
} 

但编译时触发以下错误：

error C2100: 非法间接寻址
message : see the reference at the instanciation of model: 'std::optionalecs::comp::HitBox std::getecs::comp::HitBox,ecs::comp::Stat,ecs::comp::Position,ecs::comp::HitBox,ecs::comp::Rotation,ecs::comp::Id(Tupleecs::comp::Stat,ecs::comp::Position,ecs::comp::HitBox,ecs::comp::Rotation,ecs::comp::Id &) noexcept' at compilation

要求不使用别名或取消继承，解决该编译错误。

错误分析 #

1. 缺少typename关键字：在模板中访问依赖于模板参数的嵌套类型（如tuple_optional<std::tuple<Ts...>>::type）时，编译器无法区分这是类型还是成员变量，必须用typename标记明确为类型。
2. 类型歧义问题：如果Tuple的模板参数存在重复类型（如示例中的ecs::comp::HitBox），std::get<std::optional<T>>会因为基类std::tuple中有多个相同类型元素而触发歧义。
3. 不必要的拷贝：原代码中static_cast生成临时对象，返回值会导致额外拷贝，不符合std::get的设计逻辑。

修正后的实现 #

方案一：修复类型转换并添加索引辅助

namespace std
{
    // 辅助模板：查找目标类型在模板参数列表中的索引
    template<class T, class... Ts>
    struct tuple_index;

    template<class T, class... Ts>
    struct tuple_index<T, T, Ts...> : std::integral_constant<std::size_t, 0> {};

    template<class T, class U, class... Ts>
    struct tuple_index<T, U, Ts...> : std::integral_constant<std::size_t, 1 + tuple_index<T, Ts...>::value> {};

    template<class T, class ...Ts>
    std::optional<T>& get(Tuple<Ts...> &_tuple) noexcept
    {
        // 使用typename标记嵌套类型，并转换为基类引用而非临时对象
        auto& base_tuple = static_cast<typename tuple_optional<std::tuple<Ts...>>::type&>(_tuple);
        // 通过索引获取元素，避免同类型歧义
        return std::get<tuple_index<T, Ts...>::value>(base_tuple);
    }
}

方案二：利用继承隐式转换简化代码

由于Tuple直接继承自目标std::tuple，可以直接对_tuple使用std::get，无需显式转换：

namespace std
{
    template<class T, class... Ts>
    struct tuple_index;

    template<class T, class... Ts>
    struct tuple_index<T, T, Ts...> : std::integral_constant<std::size_t, 0> {};

    template<class T, class U, class... Ts>
    struct tuple_index<T, U, Ts...> : std::integral_constant<std::size_t, 1 + tuple_index<T, Ts...>::value> {};

    template<class T, class ...Ts>
    std::optional<T>& get(Tuple<Ts...> &_tuple) noexcept
    {
        return std::get<tuple_index<T, Ts...>::value>(_tuple);
    }
}

核心要点 #

• typename的强制使用：在模板中访问依赖型嵌套类型必须添加typename，否则编译器会解析为成员变量，触发C2100错误。
• 索引式查找替代类型查找：当存在重复模板参数时，类型查找会产生歧义，通过索引定位元素是唯一可靠的方式。
• 返回引用：符合std::get的常规行为，避免不必要的拷贝操作，提升性能。

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