Move vector> to a vector>

Question

I have two classes, say Base and Derived: public Base and two std::vectors, one holding elements of type unique_ptr<Base> and other one holds elements of type unique_ptr<Derived> How can I transfer ownership of all elements from second vector into first one? I already tried:

vector<unique_ptr<Base>> v1;
vector<unique_ptr<Derived>> v2;
// do something
std::move(v2.begin(),v2.end(),v1.begin()); // This line crashed
v1 = std::move(v2); // And this gives a compiler error

Are you doing anything to make sure `v1` is the proper size before moving into it? — Vaughn Cato, Jun 01 '14 at 13:14
std::move is just a cast, it does not do the move the way std::copy does the copy. — isarandi, Jun 01 '14 at 13:16
@isarandi The `std::move` in the first example does move objects into other objects. — juanchopanza, Jun 01 '14 at 13:21
@juanchopanza `std::move` has no overload taking 3 parameters. — isarandi, Jun 01 '14 at 13:22
@isarandi It does: [check here](http://www.cplusplus.com/reference/algorithm/move/) — sorush-r, Jun 01 '14 at 13:24
@sorush-r: True. I never suspected that different headers will provide overloads for the same function. — isarandi, Jun 01 '14 at 13:27

Vaughn Cato · Accepted Answer · 2014-06-01T13:26:39.927

You need to make sure v1 is the proper size before moving into it. For example:

#include <algorithm>
#include <vector>
#include <memory>

using std::vector;
using std::unique_ptr;

struct Base {
};

struct Derived : Base {
};

int main()
{
  vector<unique_ptr<Base>> v1;
  vector<unique_ptr<Derived>> v2;
  v2.push_back(unique_ptr<Derived>(new Derived));
  v2.push_back(unique_ptr<Derived>(new Derived));
  v2.push_back(unique_ptr<Derived>(new Derived));
  v1.resize(v2.size());
  std::move(v2.begin(),v2.end(),v1.begin());
}

This is because the move algorithm doesn't change the size of the container itself. It is implemented like this (taken from http://en.cppreference.com/w/cpp/algorithm/move):

template<class InputIt, class OutputIt>
OutputIt move(InputIt first, InputIt last, OutputIt d_first)
{
    while (first != last) {
        *d_first++ = std::move(*first++);
    }
    return d_first;
}

If needed more than once, can be usefully abstracted into a function `move_to` (say) which produces an instance of specified collection type, with the items of specified collection moved over. Like `move_to>>( v2 ).swap( v1 )`. — Cheers and hth. - Alf, Jun 01 '14 at 14:15

score 6 · Answer 2 · answered Jun 02 '14 at 14:26

As I did not see this answer elsewhere, I wanted to remind everyone of the very simple member function assign of vector:

vector<unique_ptr<Base>> v1;
vector<unique_ptr<Derived>> v2;
// do something
v1.assign(make_move_iterator(v2.begin()), make_move_iterator(v2.end()));

score 1 · Answer 3 · answered Jun 01 '14 at 13:21

1

Do it elementwise.

for (auto&& elem : v2)
{
    v1.push_back(std::move(elem));
}

answered Jun 01 '14 at 13:21

isarandi

3,120
25
35

+1 simple and effective. clear and readable. forgot to clear the destination but that's not required by the OP. – Cheers and hth. - Alf Jun 01 '14 at 14:19

score 0 · Answer 4 · answered Jun 01 '14 at 13:24

0

You may use the following:

std::vector<std::unique_ptr<Base>> v1(v2.size());

std::copy(std::make_move_iterator(v2.begin()), std::make_move_iterator(v2.end()), v1.begin());

answered Jun 01 '14 at 13:24

Jarod42

203,559
14
181
302

score 0 · Answer 5 · answered Jun 01 '14 at 16:54

template<class Dest, class Src>
void move_contents_to(Dest&dest, Src const& src)=delete;
template<class Dest, class Src>
void move_contents_to(Dest&dest, Src& src)=delete;
template<class Dest, class Src>
void move_contents_to(Dest&dest, Src&& src){
  using std::begin; using std::end;
  dest = Dest{std::make_move_iterator(begin(src)),std::make_move_iterator(end(src))};
}

the above will work for most std containers, and will work with raw C style arrays on the right. For safety, I require the src to be an rvalue reference, so which is being moved is clear.

Move vector> to a vector>

5 Answers5