c++ - 从参数包中提取成员类型

Question

我想定义一个函数，该函数接受任意数量的容器，并且该数量减去一个参数以及除最后一个容器之外的所有容器的相应 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

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