模拟与性病的std ::向前:: forward_as_tuple

Question

比方说，我用std::forward_as_tuple给函数调用的参数存储在一个元组

auto args = std::forward_as_tuple(std::forward<Args>(args)...); 

然后，我通过左值引用传递这个元组想要的功能用另一个std::integer_sequence确定的args中的一些参数调用函数foo()。我std::move()做到像这样

template <typename TupleArgs, std::size_t... Indices> 
decltype(auto) forward_to_foo(TupleArgs&& args, 
           std::index_sequence<Indices...>) { 
    return foo(std::get<Indices>(std::move(args))...); 
} 

而且这样的工作，因为std::get<std::tuple>回报std::tuple_element_t<Index, tuple<Types...>>&&这与&&折叠std::tuple_element_t<Index, tuple<Types...>>因为参考的基准岬的身份转变右值合格的版本。

因此，如果std::tuple_element_t<Index, tuple<Types...>>的计算结果为T&返回的类型将是T& &&这只是T&。原因类似std::tuple_element_t<Index, tuple<Types...>>返回T&&和T

我错过了什么吗？有些情况下会失败吗？

Answer 1

template <typename TupleArgs, std::size_t... Indices> 
decltype(auto) forward_to_foo(TupleArgs&& args, 
          std::index_sequence<Indices...>) { 
    return foo(std::get<Indices>(std::forward<TupleArgs>(args))...); 
} 

这是正确的实现。

使用应该像：

auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...); 
forward_to_foo(std::move(tuple_args), std::make_index_sequence<sizeof...(args)>{}); 

这里有一些区别。

首先，我们通过转发参考，而不是通过左值参考。这让调用者为我们提供了右值（prvalue或xvalue）元组。

二，我们转发元组进入std::get调用。这意味着如果元组被移动到我们的中，我们只能通过get右值参考。我们搬到forward_to_foo。这确保了上述做的是正确的事情。

现在想象一下，如果我们想拨打foo两次。

auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...); 
auto indexes = std::make_index_sequence<sizeof...(args)>{}; 
forward_to_foo(tuple_args, indexes); 
forward_to_foo(std::move(tuple_args), indexes); 

我们没有接触forward_to_foo可言的，我们从来没有从任何args不止一次的移动。

与您最初的实现，以forward_to_foo任何调用默默地从TupleArgs右值引用或值移动，而不会在调用点，我们是第一个参数破坏的迹象。

除了这个细节，是模拟转发。

---

我自己我只是写了notstd::apply：

namespace notstd { 
    namespace details { 
    template <class F, class TupleArgs, std::size_t... Indices> 
    decltype(auto) apply(F&& f, TupleArgs&& args, 
         std::index_sequence<Indices...>) { 
     return std::forward<F>(f)(std::get<Indices>(std::forward<TupleArgs>(args))...); 
    } 
    } 
    template <class F, class TupleArgs> 
    decltype(auto) apply(F&& f, TupleArgs&& args) { 
    constexpr auto count = std::tuple_size< std::decay_t<TupleArgs> >{}; 
    return details::apply(
     std::forward<F>(f), 
     std::forward<TupleArgs>(args), 
     std::make_index_sequence<count>{} 
    ); 
    } 
} 

然后我们做：

auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...); 
auto call_foo = [](auto&&...args)->decltype(auto){ return foo(decltype(args)(args)...); }; 
return notstd::apply(call_foo, std::move(tuple_args)); 

其移动棘手位为notstd::apply，它试图匹配std::apply语义，它可以让你用更加标准的代码代替它。