从参数包中提取成员类型

Question

我想定义一个函数，它接受任意数量的容器，并且该数量减去一个参数，除最后一个容器外，所有容器的参数分别为 value_types。

我可以轻松提取最后一个容器的 value_type 并将其用作 return 类型，但是，我对定义参数类型一无所知。我想在 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

Answer 1

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

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...>&);

从参数包中提取成员类型

Extracting member types from a parameter pack

c++

containers

templates

variadic

variadic-templates