spawn a copy as input to function taking rvalue reference

Question

I have a library function (not under my control here) which take an r value reference to the movable and copyable type Bar:

void foo(Bar&& b);

In my own code, I sometimes need to give it a copy of an existing value, such as

const auto b = getBar();
foo(mk_copy(b));
b.baz();

This is what comes to mind,

template<typename T> auto mk_copy(T val){return val;}

Is there a standard way to do this, or a more common pattern? Perhaps even

template<typename T> auto mk_copy(T&& val){return std::forward<T>(val);}

Or, as pscill points out just writing the name of the class again,

foo(Bar(b));

but I prefer not to repeat type names.

Answer 1

There is no standard mechanism, but if you want one, your examples aren't very good. The first mk_copy copies T twice (or copies and moves). The second one seems very confusing as to what it's trying to do.

The obvious way is to simply take a const T&, like you normally would:

template<typename T> T mk_copy(const T &val){return val;}

Answer 2

For the built-in types the prefix + plays the role of “make a copy”:

void foo( char&& ) {}
void bar( double*&& ) {}

auto main() -> int
{
    char x{};
    foo( +x );

    double* p{};
    bar( +p );
}

Still, it would probably be confusing to readers of the code if you applied prefix + to some other type, and a general prefix operator+ template might end up in conflict with some class' own prefix operator+.

So, I suggest using the now apparent naming convention for makers, namely a make prefix.

Then it can look like this:

template< class Type >
auto make_copy( Type const& o ) -> Type { return o; }

---

Your first proposed solution,

template<typename T> auto mk_copy(T val){return val;}

suffers from potentially copying the value twice: first copying to the by-value argument, and then copying to the function result.

This is not a problem for a movable type such as a standard library container, because the return type copying will reduce to a move. But it can be a problem for largish non-movable type, as can occur in legacy code.

---

The second proposed solution,

template<typename T> auto mk_copy(T&& val){return std::forward<T>(val);}

takes the argument by forwarding reference (a.k.a. universal reference), and then deduces the return type from a re-creation of the argument type. The return type will always be a non-reference, since that's what plain auto deduces, so this is technically correct. But it's needlessly complicated.

Answer 3

I think you'd better just define that mk_copy method, or add one more declaration:

auto b_copy = b;
foo(std::move(b_copy));

These are clearer to the readers.

---

Just to demonstrate the possibilities, you could use decltype to get the type:

foo(std::decay_t<decltype(b)>{b});

or you could get the same effect with lambdas:

foo([&]{return b;}());

or tuples:

foo(std::get<0>(std::make_tuple(b)));

or pairs:

foo(std::make_pair(b, 0).first);