从参数包中提取成员类型

Extracting member types from a parameter pack

本文关键字：成员类 类型 成员 提取 参数 包中      更新时间：2023-10-16

我想定义一个函数，该函数接受任意数量的容器，该数字减去一个参数，除最后一个容器外，其他所有容器的value_types。

我可以轻松地提取最后一个容器的value_type并将其用作返回类型，但是，我对定义参数的类型一无所知。我会想象在 std：：tuple_element_t 中折叠一个 std：：integer_sequence 可能是一种方法，但我未能让它工作。

// example: 1D interpolator
template<typename... ContainerTypes>
typename std::tuple_element_t<
    sizeof...(ContainerTypes) - 1,
    std::tuple<ContainerTypes...>>::value_type
interpolate(const ContainerTypes& ... /*, ??? */)
{
    // (...)
    return {};
}
// intended use
std::array<int, 2> x{0, 2};
std::array<double, 2> y{0, 2};
int x_query{1};
double y_interpolated{interpolate(x, y)}; // compiles
//double y_interpolated{interpolate(x, y, x_query)}; // this is what I want

据我了解，您想转换重载：

template <typename C1, typename CLast>
typename CLast::value_type interpolate(const C1&,
                                       const CLast&,
                                       typename C1::value_type);
template <typename C1, typename C2, typename CLast>
typename CLast::value_type interpolate(const C1&, const C2&,
                                       const CLast&
                                       typename C1::value_type, typename C2::value_type);
// ...

变成可变参数模板。

拥有中间结构会更容易：

template <typename T, typename ... Ts>
struct InterpolatorImpl
{
    const T& t;
    std::tuple<const Ts&...> ts;
    InterpolatorImpl(const T& t, const Ts&... ts) : t(t), ts(ts...) {}
    typename T::value_type operator()(typename Ts::value_type...) const {/*...*/};
};

template <std::size_t...Is, typename Tuple>
auto InterpolatorHelper(std::index_sequence<Is...>, const Tuple& tuple) {
    using LastType = tuple_element_t<sizeof...(Is), tuple>;
    return InterpolatorImpl<LastType,
                            std::decay_t<std::tuple_element_t<Is, tuple>>...>
        {
            std::get<sizeof...(Is)>(tuple),
            std::get<Is>(tuple)...
        };
}
template <typename ...Ts>
auto Interpolator(const Ts&... ts) {
    return InterpolatorHelper(std::make_index_sequence<sizeof...(Ts) - 1>(),
                              std::tie(ts...));
}

然后，称之为：

std::array<int, 2> x{0, 2};
std::array<double, 2> y{0, 2};
int x_query{1};
double y_interpolated{Interpolator(x, y)(x_query)};

或将您的签名更改为

template <typename ... InputContainers, typename TargetContainer>
typename TargetContainer::value_type
interpolate(const std::tuple<InputContainers...>&,
            const TargetContainer&,
            const std::tuple<typename InputContainers::value_type...>&);
相关文章：