C ++：获取参数包的开头和结尾

如何解决C ++：获取参数包的开头和结尾

如何获取参数包的前n个元素？还是一般来说[n，n + 1，...，m）中的最后n个元素或元素切片？例如：

df = df.assign(course_code = lambda x: x['course_code'].apply(lambda s: s.split(' - ')[0]))

这可以通过结合std :: tuple，std :: integer_sequence和std :: get来实现，但我想知道是否还有更简单的方法。

解决方法

template <typename T,typename... J>
T GetFirstPack(T t,J... j) {
    return t;
}

template <typename T>
T GetLastPack(T t) {
    return t;
}
template <typename T,typename...J>
auto GetLastPack(T t,J... j) {
    return GetLastPack(j...);
}

template <typename... T>
void TestFunction(T... t) {
    std::cout << GetFirstPack(t...) << std::endl;
    std::cout << GetLastPack(t...) << std::endl;
}

int main() {
    // your code goes here
    TestFunction("first","second",10);
    return 0;
}

首先要考虑的是琐碎的事，最后要考虑拆箱规则会比较棘手。您可以使用rhr使其更有效率。

,

有一种方法可以为 std::integer_sequence 创建一个新的工厂别名，通过使用 std::tuple、std::integer_sequence、 std::get。

假设这个别名的名称是 make_consecutive_integer_sequence：

namespace detail {
  template <typename T,auto Start,auto Step,T... Is>
  constexpr auto make_cons_helper_impl_(std::integer_sequence<T,Is...>) {
    auto eval_ = [](const T& I) consteval -> T { return Start + Step * I; };
    return std::integer_sequence<T,eval_(Is)...>{};
  }

  template <typename T,auto Count,auto Step>
  constexpr auto make_cons_impl_() {
    return make_cons_helper_impl_<T,Start,Step>(std::make_integer_sequence<T,Count>{});
  }
} // namespace detail

template <std::integral T,auto Step = 1>
using make_consecutive_integer_sequence = decltype(
  detail::make_cons_impl_<T,Count,Step>()
);

template <auto Start,auto Step = 1>
using make_consecutive_index_sequence = make_consecutive_integer_sequence<std::size_t,Step>;

然后，应用 make_consecutive_integer_sequence 的用法：

template <std::size_t N>
using make_first_n_index_sequence = make_consecutive_index_sequence<0,N>;

template <std::size_t N,std::size_t S>
using make_last_n_index_sequence = make_consecutive_index_sequence<S - N,N>;

template <std::size_t B,std::size_t E>
using make_slice_index_sequence = make_consecutive_index_sequence<B,E - B>;

我们仍然需要将参数包包装到 std::tuple 中。

template <typename... Ts,std::size_t... Is>
constexpr auto get_subpack_by_seq(std::index_sequence<Is...>,Ts&&... args) {
    return std::make_tuple(std::get<Is>(std::forward_as_tuple(args...))...);
}

template <std::size_t N,typename... Ts>
requires (N <= sizeof...(Ts))
constexpr auto head(Ts&&... args) {
    return get_subpack_by_seq(
        make_first_n_index_sequence<N>{},std::forward<Ts>(args)...
    );
}

template <std::size_t N,typename... Ts>
requires (N <= sizeof...(Ts))
constexpr auto tail(Ts&&... args) {
    return get_subpack_by_seq(
        make_last_n_index_sequence<N,sizeof...(Ts)>{},std::forward<Ts>(args)...
    );
}

template <std::size_t B,std::size_t E,typename... Ts>
requires (B < E && B <= sizeof...(Ts) && E <= sizeof...(Ts))
constexpr auto slice(Ts&&... args) {
    return get_subpack_by_seq(
        make_slice_index_sequence<B,E>{},std::forward<Ts>(args)...
    );
}

这里的目标是概括 make_consecutive_integer_sequence（make_consecutive_index_sequence 为 std::size_t），以便我们可以为 head、tail 和slice 以一致的方式。

编译时断言：

static_assert(head<3>(1,2.0f,"three",'4') == std::make_tuple(1,"three"));
static_assert(tail<2>(1,'4') == std::make_tuple("three",'4'));
static_assert(slice<1,3>(1,'4') == std::make_tuple(2.0f,"three"));