Hiding move semantics behind single function

Question

e.g. I have a function that can handle const T & and T && values:

template <typename T>
/* ... */ foo(const T &) {
std::cout << "const T & as arg" << std::endl;
}

template <typename T>
/* ... */ foo(T &&) {
std::cout << "T && as arg" << std::endl;
}

Is there a way that I can write a single function, that handles both types automatically? As in:

template <typename T>
/* ... */ bar(T t) {
    foo(t);
}

So that:

T a;
bar(a); // Handles as const T &
T b;
bar(std::move(b)); // Handles as T &&

Thank you!

See `std::forward` and universal references: http://stackoverflow.com/questions/3582001/advantages-of-using-forward — Chris Drew, Jul 03 '14 at 10:54
Are you sure your existing functions work as you think? `foo(a)` and `foo(std::move(b))` will call the same function. — Jonathan Wakely, Jul 03 '14 at 11:13
Regarding to Chris comment, note that your second overload doesn't take rvalues only, its an universal reference, so the `"T && as arg"` assumption is false. — Manu343726, Jul 03 '14 at 11:16

Shoe · Answer 1 · 2014-07-03T11:45:05.187

You can use reference collapsing and std::forward to forward the argument to the foo function:

template <typename T>
/* ... */ bar(T&& t) {
    foo(std::forward<T>(t));
}

Please notice that your foo function will accept rvalues, constant lvalues and non-const lvalues. As an example, given:

const int x = 456;
int y = 123;

then:

foo(123);   // foo(T&&)
foo(x);     // foo(const T&)
foo(y);     // foo(T&&)

Live demo

Hiding move semantics behind single function

1 Answers1