从参数包中排除前 n 个参数

Exclude first n arguments from parameter pack

本文关键字：参数 排除 包中      更新时间：2023-10-16

我有一个函数foo，它调用一个函数bar，其中包含传递到foo的可变参数模板中的类型子集。例如：

template <typename... T>
void foo() {
// ...
template <size_t start_idx, typename... T>
using param_pack = /*Parameter pack with T[start_idx]...T[N]*/
auto b = bar<param_pack<2, T...>>();
// ...
}

有没有办法提取"子参数包"。在上述情况下 如果是T = [int float char double]，则param_pack<2, T...> = [char double]

[编辑]

我的目标是能够使用这样的东西来匹配事件处理程序。例如

struct ev {};
template <typename... T>
struct event : ev {
std::tuple<T...> data_;
event(T&&... d) : data_(std::make_tuple(std::forward<T>(d)...)) {}
};
template <typename... Functor>
struct handler {
std::tuple<Functor...> funcs_;
handler(Functor&&... f) : funcs_(std::make_tuple(std::forward<Functor>(f)...)) {}
void handle_message(ev* e) {
auto ptrs = std::make_tuple(
dynamic_cast<event<param_pack<1, typename function_traits<F>::args>>*>(e)...
); 
match(ptrs);
}
};

在这里，function_traits::args获取函数参数的参数包，并在检查dynamic_cast是否成功并执行第一个成功的函数funcs_对元组进行匹配迭代。我已经实现了这些。

处理程序类似于

[] (handler* self, <ARGS>) -> void {
// ...
}

我本质上是在试图摆脱self论点。

为了简单起见，撇开它缺少对索引N的检查这一事实，这里有一个基于函数声明(不需要定义(和 using 声明的可能解决方案：

template<std::size_t N, typename... T, std::size_t... I>
std::tuple<std::tuple_element_t<N+I, std::tuple<T...>>...>
sub(std::index_sequence<I...>);
template<std::size_t N, typename... T>
using subpack = decltype(sub<N, T...>(std::make_index_sequence<sizeof...(T) - N>{}));

这种方法的好处是，您不必引入围绕元组设计的新类型，然后以某种方式迭代地对其进行专用化。

它遵循一个使用上述代码的最小工作示例：

#include<functional>
#include<tuple>
#include<cstddef>
#include<type_traits>
template<std::size_t N, typename... T, std::size_t... I>
std::tuple<std::tuple_element_t<N+I, std::tuple<T...>>...>
sub(std::index_sequence<I...>);
template<std::size_t N, typename... T>
using subpack = decltype(sub<N, T...>(std::make_index_sequence<sizeof...(T) - N>{}));
int main() {
static_assert(std::is_same<subpack<2, int, float, char, double>, std::tuple<char, double>>::value, "!");
}

查看在 wandbox 上启动和运行的完整示例。

包含对索引N检查的扩展版本如下所示：

template<std::size_t N, typename... T, std::size_t... I>
std::enable_if_t<(N < sizeof...(T)), std::tuple<std::tuple_element_t<N+I, std::tuple<T...>>...>>
sub(std::index_sequence<I...>);

这是您在第一个示例中看到的类型，一旦包裹在std::enable_if_t中，仅此而已。同样，声明就足够了，不需要定义。

编辑

如果要使用自己的类模板而不是std::tuple，则可以轻松修改代码以执行此操作：

#include<functional>
#include<tuple>
#include<cstddef>
#include<type_traits>
template<typename...>
struct bar {};
template<template<typename...> class C, std::size_t N, typename... T, std::size_t... I>
std::enable_if_t<(N < sizeof...(T)), C<std::tuple_element_t<N+I, std::tuple<T...>>...>>
sub(std::index_sequence<I...>);
template<template<typename...> class C, std::size_t N, typename... T>
using subpack = decltype(sub<C, N, T...>(std::make_index_sequence<sizeof...(T) - N>{}));
int main() {
static_assert(std::is_same<subpack<bar, 2, int, float, char, double>, bar<char, double>>::value, "!");
}

编辑

根据添加到问题中的代码，上面的解决方案仍然有效。您应该按如下方式定义event类：

struct ev {};
template <typename>
struct event;
template <typename... T>
struct event<std::tuple<T...>>: ev {
// ...
};

这样，当您执行此操作时：

event<param_pack<1, typename function_traits<F>::args>>

您仍然可以从param_pack中获得一个元组(这是我示例中使用声明的subpack(，但它与event的模板部分专用化匹配，并且参数包可供您使用T...。

这是你能做的最好的事情，因为你不能将参数包放在 using 声明中。无论如何，它只是工作，所以它可能可以解决你的问题。

你可以做这样的事情：

template <std::size_t N, typename ... Ts> struct drop;
template <typename ... Ts>
struct drop<0, Ts...>
{
using type = std::tuple<Ts...>;
};
template <std::size_t N, typename T, typename ... Ts>
struct drop<N, T, Ts...>
{
using type = typename drop<N - 1, Ts...>;
};
// Specialization to avoid the ambiguity
template <typename T, typename... Ts>
struct drop<0, T, Ts...>
{
using type = std::tuple<T, Ts...>;
};

这是一个快速但不是特别可重用的解决方案。

template <typename Pack, std::size_t N, std::size_t... Is>
void invoke_bar_impl(std::index_sequence<Is...>) {
bar<std::tuple_element_t<N + Is, Pack>...>();
}
template <std::size_t N, typename... Ts>
void invoke_bar() {
auto indices = std::make_index_sequence<sizeof...(Ts) - N>();
invoke_bar_impl<std::tuple<Ts...>, N>(indices);
}
相关文章：