如何更改参数包中的最后一个参数？

Question

我有一个函数f1()

template <typename... Args>
void f1(Args... args)
{
    // the implementation is just an example, I don't really need a complicated
    // way to sum numbers
    boost::fusion::vector<Args...> v(args...);
    std::cout << boost::fusion::accumulate(v, 0, [](auto i1, auto i2) { return i1 + i2; }) << std::endl;
}

我想从函数 f2() 中调用它，但最后一个参数不同。有没有简单的方法？我尝试了一个幼稚的

template <typename... Args>
struct CallHelper;

template <>
struct CallHelper<>
{
    template <typename... Args>
    static void Apply(Args... args) { f1(args...); }
};

template <typename A0>
struct CallHelper<A0>
{
    template <typename... Args>
    static void Apply(Args ...args, A0 a0)
    {
        // substitute 10 to the last argument
        CallHelper<>::Apply(args..., 10);
    }
};

template <typename Head, typename ...TailArgs>
struct CallHelper<Head, TailArgs...>
{
    template <typename... Args>
    static void Apply(Args... args, Head head, TailArgs ...tailArgs)
    {
        CallHelper<TailArgs...>::Apply(args..., head, tailArgs...);
    }
};

template <typename... Args>
void f2(Args... args)
{
    CallHelper<Args...>::Apply(args...);
}

当然不行，因为Head head不是第一个参数。也许还有一种方法可以使 Head head 成为参数包？或者还有什么我可以做的吗？

Answer 1

在索引序列的帮助下...

#include <utility>
#include <iostream>

template <typename ... Args>
void f1 (Args ... args)
 {
   using unused=int[];

   (void)unused { 0, (std::cout << args << ", ", 0)... };

   std::cout << std::endl;
 }

template <std::size_t>
struct getVal
 {
   template <typename T1, typename T2>
   T2 operator() (T1 const &, T2 const & t2)
    { return t2; }
 };

template <>
struct getVal<0U>
 {
   template <typename T1, typename T2>
   T1 operator() (T1 const & t1, T2 const &)
    { return t1; }
 };

template <std::size_t ... Is, typename ... Args>
void f2_helper (std::index_sequence<Is...> const &, Args const & ... args)
 { f1 ( getVal<sizeof...(Is)-Is-1U>()(10, args)... ); }

template <typename ... Args>
void f2 (Args ... args)
 { f2_helper(std::make_index_sequence<sizeof...(Args)>{}, args...); }

int main()
 {
   f1(1, 2L, 3.3, "ten"); // print 1, 2, 3.3, ten,
   f2(1, 2L, 3.3, "ten"); // print 1, 2, 3.3, 10,
 }

这是一个 C++14 解决方案（需要 std::index_sequence 和 std::make_index_sequence），但如果需要，应该很简单地创建 C++11 的替代品。

Answer 2

您可以将参数作为元组转发，然后使用 std::integer_sequence 解压除最后一个以外的所有参数。这段代码看起来比你的方法简单得多：

template<typename... Args>
void f1(Args... args)
{
    boost::fusion::vector<Args...> v(args...);
    std::cout << boost::fusion::accumulate(v, 0, [](auto i1, auto i2) { return i1 + i2; }) << std::endl;
}

template<typename Tuple, size_t... idx>
void callImpl(Tuple&& tuple, std::index_sequence<idx...>)
{
    f1(std::get<idx>(std::forward<Tuple>(tuple))..., 10);
}

template<typename... Ts>
void callWithLast10(Ts&&... ts)
{
    callImpl(std::forward_as_tuple(ts...), std::make_index_sequence<sizeof...(Ts) - 1>());
}

用法：

f1(1, 2, 3, 4); // Prints 10
callWithLast10(1, 2, 3, 4); // Prints 16

Answer 3

就post我在评论中提到的

#include <utility>
#include <iostream>

template<bool b, typename T1, typename T2>
decltype(auto) replace_if(T1&& t1, T2&& t2)
{
    if constexpr(b)
        return std::forward<T1>(t1);
    else
        return std::forward<T2>(t2);
}

template<typename... Args>
void f1(Args&&... args)
{
    (std::cout << ... << args) << std::endl;
}

template<typename T, typename... Args, size_t... I>
decltype(auto) replace_last_impl(std::index_sequence<I...>, T&& t, Args&&... args)
{
    return f1(replace_if<sizeof...(Args) - 1 == I>(std::forward<T>(t), std::forward<Args>(args))...);
}

template<typename T, typename... Args>
decltype(auto) replace_last(T&& t, Args&&... args)
{
    return replace_last_impl(std::index_sequence_for<Args...>{}, std::forward<T>(t), std::forward<Args>(args)...);
}

int main()
{
    f1(1, 2, 3);  // 123
    replace_last("three", 1, 2, 3);  // 12three
}

节目的明星是replace_if，这是一种非常通用的参数包转换方式。

Answer 4

有一些简单的方法可以解决这个问题，包括编写多个特定于问题的函数来解决这个问题。

我不喜欢那样。

所以我首先写了一些辅助函数。 nth 接受一个索引和一堆参数，returns nth 其中一个：

template<std::size_t I, class...Args>
decltype(auto) nth( Args&&... args ) {
  return std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...));
}

index_over 和 index_upto 允许您在函数中扩展 size_t 的 inline 的参数包。这摆脱了为解包而创建辅助函数的麻烦：

template<std::size_t...Is>
auto index_over( std::index_sequence<Is...> ) {
  return [](auto&& f)->decltype(auto) {
    return decltype(f)(f)( std::integral_constant< std::size_t, I >{} );
  };
}
template<std::size_t N>
auto index_upto( std::integral_constant< std::size_t, N > ={} ) {
  return index_over( std::make_index_sequence<N>{} );
}

然后，我们写 f2:

template<class...Args>
void f2( Args&&... args ) {
  index_upto< sizeof...(args)-1 >()(
    [&](auto...Is) {
      f1( nth<Is>(std::forward<Args>(args)...)..., 10 );
    }
  )
}

完成。

这确实会产生二次方数量的未使用引用，一个好的编译器可以优化掉这些引用，但需要时间（在编译时）。

如何更改参数包中的最后一个参数？

How to change the last argument in the parameter pack?

c++

templates

variadic-templates

generic-lambda

c++14