How to move an unique_ptr from a parameter pack inside a template method

Question

I want to pass a parameter pack into a template method that creates a new instance of an object of a type specified by another template argument.

Minimal code example:

my code actually does more operations with the created type and the handler

template<typename T, typename... Args>
static bool CreateAndDo(Handler & rHandler, Args.. args)
{
  auto pT = T::Create(args...);
  rHandler.DoStuff(std::move(pT));
}

Simple Usage:

Handler tHander;
// the 0 is just an example of an argument
CreateAndDo<ConcreteType>(tHander, 0);

Now my problem is that one of my arguments is a std::unique_ptr.

auto pPtr = std::make_unique<ConcreteArg>();
CreateAndDo<ConcreteType>(tHander, std::move(pPtr));

This fails to compile, because the std::unique_ptr would have to be moved by CreateAndDo Method. I know that I need to keep moving the arguments but I don't know how to do that with a parameter pack.

How could I accomplish this?

```std::forward``` exists exactly for such things. Please take a look at https://stackoverflow.com/questions/6829241/perfect-forwarding-whats-it-all-about — grungegurunge, Jan 11 '19 at 11:52

Lightness Races in Orbit · Accepted Answer · 2019-01-11T12:46:52.387

5

Well, why don't you move args...?

You're always copying, inside CreateAndDo. There's no reason to, and it forbids you from passing move-only args, as you've found.

I can't see that this has anything to do with templates or parameter packs, really, unless the issue is that it was unclear how to accomplish a move in that situation. The question isn't how to pass a unique_ptr to a parameter pack, but what to do with it afterwards, and that is just the same as you would without a parameter pack — move a unique_ptr around.

You should forward the args, which effectively does a move when appropriate and a copy otherwise. You'll need the argument to be a forwarding reference, too.

template<typename T, typename... Args>
static bool CreateAndDo(Handler & rHandler, Args&&.. args)
{
  auto pT = T::Create(std::forward<Args>(args)...);
  rHandler.DoStuff(std::move(pT));
}

So the problem is that you only moved at one part of the chain of function calls, but not the second part, resulting in an unnecessary — and sometimes impossible — copy.

edited Jan 11 '19 at 12:46

answered Jan 11 '19 at 11:54

Lightness Races in Orbit

358,771
68
593
989

Perfekt answer! Thank you very much! You are right with your assumption that I didn't know how to move it inside a template. Should I rephrase the question? – The Shmoo Jan 11 '19 at 12:02
1

Might not hurt tbh. At least the title and perhaps add into the question that you know you need to keep moving the args but don't know how to do that with a pack – Lightness Races in Orbit Jan 11 '19 at 12:04
@TheShmoo: Nice one – Lightness Races in Orbit Jan 11 '19 at 12:21
1

@LightnessRacesinOrbit Shouldn't that be `std::forward(args)...`, i.e. without the `&&`? – j6t Jan 11 '19 at 12:43
@j6t: Yes, it absolutely should :) – Lightness Races in Orbit Jan 11 '19 at 12:45
Ah, and the parameter should then actually be `Args&&... args`. – j6t Jan 11 '19 at 12:45
gaaaaaaaaaaaaah – Lightness Races in Orbit Jan 11 '19 at 12:46
1

@TheShmoo Please be sure to check out the updates - thanks to j6t! – Lightness Races in Orbit Jan 11 '19 at 12:47

How to move an unique_ptr from a parameter pack inside a template method

1 Answers1