Is it possible to omit template parameter in `std::forward`?

Question

The standard signature of std::forward is:

template<typename T>
constexpr T&& forward(std::remove_reference_t<T>&) noexcept;
template<typename T>
constexpr T&& forward(std::remove_reference_t<T>&&) noexcept;

Because the parameter type isn't T directly, we should specify the template argument when using std::forward:

template<typename... Args>
void foo(Args&&... args)
{
    bar(std::forward<Args>(args)...);
}

However sometimes the template argument is not as simple as Args. auto&& is a case:

auto&& vec = foo();
bar(std::forward<decltype(vec)>(vec));

You can also imagine more complicated template argument types for std::forward. Anyway, intuitively std::forward should know what T is but it actually don't.

So my idea is to omit <Args> and <decltype(vec)> no matter how simple they are. Here is my implementation:

#include <type_traits>

template<typename T>
std::add_rvalue_reference_t<std::enable_if_t<!std::is_lvalue_reference<T>::value, T>>
my_forward(T&& obj)
{
    return std::move(obj);
}

template<typename T>
T& my_forward(T& obj)
{
    return obj;
}

int main()
{
    my_forward(1); // my_forward(int&&)
    int i = 2;
    my_forward(i); // my_forward(int&)
    const int j = 3;
    my_forward(j); // my_forward(const int&)
}

When obj is rvalue reference, for example int&&, the first overload is selected because T is int, whose is_lvalue_reference is false;

When obj is lvalue reference, for example const int&, the second overload is selected because T is const int& and the first is SFINAE-ed out.

If my implementation is feasible, why is std::forward still requiring <T>? (So mine must be infeasible.)

If not, what's wrong? And still the question, is it possible to omit template parameter in std::forward?

Answer 1

The problematic case is when you pass something of rvalue reference type but which does not belong to an rvalue value category:

int && ir{::std::move(i)};
my_forward(ir); // my_forward(int&)

Passing type to std::forward will ensure that arguments of rvalue reference types will be moved further as rvalues.

Answer 2

The answer by user7860670 gives you an example for the case where this breaks down. Here is the reason why the explicit template parameter is always needed there.

By looking at the value of the forwarding reference you can no longer reliably determine through overload resolution whether it is safe to move from. When passing an lvalue reference parameter as an argument to a nested function call it will be treated as an lvalue. In particular, it will not bind as an rvalue argument, that would require an explicit std::move again. This curious asymmetry is what breaks implicit forwarding.

The only way to decide whether the argument should be moved onwards is by inspecting its original type. But the called function cannot do so implicitly, which is why we must pass the deduced type explicitly as a template parameter. Only by inspecting that type directly can we determine whether we do or do not want to move for that argument.