如何转发裁剪后的参数包？实现参数包拆分给成员构造函数

问题描述 #

希望实现模板类A5<N>的构造函数，接收一个参数包后，将前N个元素转发给成员B<N>的构造函数，剩余5-N个元素转发给成员C<5-N>的构造函数。B<N>和C<5-N>的构造函数同样接收参数包，核心需求是编译期拆分参数包。

初始代码框架如下：

template<int N> struct B;

template<int N> struct C;

template<int N, typename ...Args>
auto get_first(Args&&... args);

template<int N, typename ...Args>
auto get_last(Args&&... args);

template<int N>
struct A5
{
  B<N> b;
  C<5-N> c;

  template<typename ...Args>
  A5(Args&&... args)
    : b(get_first<N>(args)...) // 需要实现参数包拆分逻辑
    , c(get_last<5-N>(args)...)
  {}
};

可行性分析 #

完全可行。核心思路是利用编译期索引序列（C14及以后标准支持，C11可自行实现），生成对应位置的索引，从参数包中精准提取所需元素，实现完美转发。

具体实现方案 #

方案1：封装get_first和get_last工具函数 #

通过辅助函数结合索引序列，提取参数包的前N个或后M个元素：

#include <tuple>
#include <utility>

// 提取前N个元素的辅助实现
template<int N, typename... Args, std::size_t... Is>
auto get_first_impl(Args&&... args, std::index_sequence<Is...>) {
    return std::forward_as_tuple(
        std::forward<Args>(std::get<Is>(std::forward_as_tuple(std::forward<Args>(args)...)))...
    );
}

template<int N, typename... Args>
auto get_first(Args&&... args) {
    static_assert(sizeof...(Args) >= N, "参数数量不足，无法提取前N个元素");
    return get_first_impl<N>(std::forward<Args>(args)..., std::make_index_sequence<N>{});
}

// 提取后M个元素的辅助实现
template<int M, typename... Args, std::size_t... Is>
auto get_last_impl(Args&&... args, std::index_sequence<Is...>) {
    constexpr std::size_t total = sizeof...(Args);
    return std::forward_as_tuple(
        std::forward<Args>(std::get<total - M + Is>(std::forward_as_tuple(std::forward<Args>(args)...)))...
    );
}

template<int M, typename... Args>
auto get_last(Args&&... args) {
    static_assert(sizeof...(Args) >= M, "参数数量不足，无法提取后M个元素");
    return get_last_impl<M>(std::forward<Args>(args)..., std::make_index_sequence<M>{});
}

// 补充B和C的示例定义
template<int N>
struct B {
    template<typename... Args>
    B(Args&&...) {}
};

template<int N>
struct C {
    template<typename... Args>
    C(Args&&...) {}
};

template<int N>
struct A5 {
    B<N> b;
    C<5 - N> c;

    template<typename... Args>
    A5(Args&&... args)
        : b(std::get<Is>(get_first<N>(std::forward<Args>(args)...))...)
        , c(std::get<Js>(get_last<5 - N>(std::forward<Args>(args)...)))...
    {
        static_assert(sizeof...(Args) == 5, "A5构造必须传入恰好5个参数");
    }
};

方案2：直接在A5构造函数中用索引序列展开（更高效） #

避免中间tuple的开销，直接在私有构造函数中利用索引序列拆分参数：

#include <utility>
#include <tuple>

template<int N> struct B;
template<int N> struct C;

template<int N>
struct B {
    template<typename... Args>
    B(Args&&...) {}
};

template<int N>
struct C {
    template<typename... Args>
    C(Args&&...) {}
};

template<int N>
struct A5 {
    B<N> b;
    C<5 - N> c;

    template<typename... Args>
    A5(Args&&... args)
        : A5(std::forward<Args>(args)..., std::make_index_sequence<N>{}, std::make_index_sequence<5 - N>{})
    {}

private:
    // 私有构造函数，接收参数包+两个索引序列
    template<typename... Args, std::size_t... BIs, std::size_t... CIs>
    A5(Args&&... args, std::index_sequence<BIs...>, std::index_sequence<CIs...>)
        : b(std::forward<Args>(std::get<BIs>(std::forward_as_tuple(std::forward<Args>(args)...)))...)
        , c(std::forward<Args>(std::get<N + CIs>(std::forward_as_tuple(std::forward<Args>(args)...)))...)
    {
        static_assert(sizeof...(Args) == 5, "A5构造必须传入恰好5个参数");
    }
};

关键说明 #

1. 编译期计算：所有索引、参数数量检查都是编译期完成，不会产生运行时开销。
2. 完美转发：通过std::forward和std::forward_as_tuple保持参数的原始值类别（左值/右值），避免不必要的拷贝。
3. 参数数量校验：用static_assert强制要求传入参数总数为5，提前发现错误。

内容的提问来源于stack exchange，提问作者iloledsohard