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

从参数包中提取成员类型

1 个答案: