主页 / coding / 问题 / 79001856
Accepted
lobelk
Asked: 2024-09-19 17:31:51 +0800 CST

如何交错 C++ 模板参数包

  • 772

我有这个 C++ 模板函数

template <int N, int B, auto... Args>
void somefunc() {
    // do work...
}

，我可以这样调用：

somefunc<1, true, 2, false>();

我想扩展 API，以便客户端somefunc也可以像这样调用：

somefunc<Pack<1, true>, Pack<2, false>>(); // equivalent to somefunc<1, true, 2, false>()

，其中Pack是某个结构：

template <int N, bool B>
struct Pack
{
    static constexpr int value = N;
    static constexpr int flag = B;
};

一种直接的方法是尝试这样的事情：

template <typename... Packs>
void somefunc() {
    somefunc<Packs::value..., Packs::flag...>();
}

但这扩展为：

somefunc<1, 2, true, false>();

而不是：

somefunc<1, true, 2, false>();

是否有一种简单的方法可以按照所述方式扩展 API？

c++

2 个回答

  1. Best Answer

    要展平包，您可以使用std::tuple：

    template <typename... Packs>
void somefunc() {
    constexpr std::tuple t = std::tuple_cat(std::tuple{Packs::value, Packs::flag}...);
    return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
        return somefunc<std::get<Is>(t)...>();
    }(std::make_index_sequence<std::tuple_size_v<decltype(t)>>());
}

    演示

    或者std::apply 需要将常量包装到std::integral_constant常规函数参数中constexpr。

    template <typename... Packs>
void somefunc() {
    constexpr std::tuple t =
        std::tuple_cat(std::tuple{std::integral_constant<int, Packs::value>{},
                                  std::integral_constant<int, Packs::flag>{}}...);
    return std::apply([](auto... args){ somefunc<args()...>(); }, t);
}

    演示

    • 2

  2. 这是一个可能的解决方案，但请注意，它仅适用于结构int中的两个Pack。

    这个想法是首先构建一个编译时数组，保存交错的值，然后可以将其作为模板参数发送给目标函数。

    #include <iostream>
#include <array>
#include <tuple>

template <int N, int B, auto... Args>
void somefunc() 
{
    // do work...
    std::cout << N << " " << B << "\n";
    if constexpr(sizeof...(Args)>0)   { somefunc<Args...>();  }
}


// see https://stackoverflow.com/questions/20162903/template-parameter-packs-access-nth-type-and-nth-element
template<int N, typename... Ts> using NthTypeOf = typename std::tuple_element_t<N, std::tuple<Ts...>>;

template <typename... Packs>
void somefunc() 
{
    constexpr int N = 2*sizeof...(Packs);
    
    // First, we build an array holding the interleaved values
    constexpr auto arr = [&]<std::size_t...Is> (std::index_sequence<Is...>)
    {
        return std::array<int, N>{ { (Is%2==0 ? NthTypeOf<Is/2,Packs...>::value : NthTypeOf<Is/2,Packs...>::flag )... }};
    } (std::make_index_sequence<N>());
    
    // Then we call the function with the array content. 
    [&]<std::size_t...Is> (std::index_sequence<Is...>)
    {
        somefunc <arr[Is]...>();
    } (std::make_index_sequence<N>());
}

template <int N, bool B>
struct Pack
{
    static constexpr int value = N;
    static constexpr int flag  = B;
};

int main()
{
    somefunc<Pack<1, true>, Pack<2, false>, Pack<3, true>>();
}

    点击此处演示

    • 0

相关问题