perfect forwading tuple values from std::get

Question

I have a nice implementation similar to std::apply that expands a tuple as arguments for a function. It works perfectly, except that std::get is always returning an lvalue and it fails to match the proper overload.

POC code can be found here: https://wandbox.org/permlink/OUYMQY2afL8vRMUu

The idea is to add std::forward to apply_sequence so it prints ONE TWO THREE

void printNumber(const int& x, const int& y)
{
    std::cout << "ONE" << std::endl;
}

void printNumber(const int& x, int&& y)
{
    std::cout << "TWO" << std::endl;
}

void printNumber(int&& x, const int& y)
{
    std::cout << "THREE" << std::endl;
}

template<typename... TTuple, std::size_t... Indices>
auto apply_sequence(const std::tuple<TTuple...>& tuple, std::index_sequence<Indices...>)
{
    // missing: forward value to proper type (currently is always lvalue)
    return printNumber(std::get<Indices>(tuple)...);
}

template<typename... TTuple>
auto apply_tuple(const std::tuple<TTuple...>& tuple)
{
    return apply_sequence(tuple, std::index_sequence_for<TTuple...>());
}

int main(int argc, char* argv[])
{
    std::tuple<int, int> one { 1, 2 };
    apply_tuple(one); // ONE

    std::tuple<int, int&&> two { 1, 2 };
    apply_tuple(two); // TWO

    std::tuple<int&&, int> three { 1, 2 };
    apply_tuple(three); // THREE

    return 0;
}

EDIT: In case someone wants the solution to the problem https://wandbox.org/permlink/XkUjfypAMepJRPgZ

I suggest you [post](https://stackoverflow.com/posts/48532450/edit) that code in here as a [mcve]. — Ron, Jan 31 '18 at 00:10
In your code example your overloads whose only difference is `int` vs. `int&&` [are indistinguishable](https://stackoverflow.com/a/17961890/1277769) — SirGuy, Jan 31 '18 at 00:13

score 1 · Accepted Answer · answered Jan 31 '18 at 07:27

The reason is that if the tuple argument is an lvalue, std::get returns an lvalue, even though the element is an rvalue reference. You can write your own my_get to resolve it:

// If the element is not an rvalue reference, behave the same as std::get
template< std::size_t I, class... Types >
constexpr std::enable_if_t <
              !std::is_rvalue_reference_v<std::tuple_element_t<I, std::tuple<Types...>>>, 
               std::tuple_element_t<I, std::tuple<Types...>>const&
          >
    my_get( const std::tuple<Types...>& t ) noexcept
{
    return std::get<I>(t);
}

// If the element is an rvalue reference, move the result of std::get
template< std::size_t I, class... Types >
constexpr std::enable_if_t <
              std::is_rvalue_reference_v<std::tuple_element_t<I, std::tuple<Types...>>>, 
              std::tuple_element_t<I, std::tuple<Types...>>
          >
    my_get( const std::tuple<Types...>& t ) noexcept
{
    return std::move(std::get<I>(t));
}

Use my_get instead of std::get in your code, then everything goes well.

thanks! I wonder why the standard `std::get` isn't implemented in this way, it makes no sense for me — Ivan Sanz Carasa, Jan 31 '18 at 08:43

perfect forwading tuple values from std::get

1 Answers1