Wrapping a unique_ptr with custom class in a container

Question

I took my first C++ class in 1990, long before your newfangled exceptions, STL and whatnot. Now I am writing a custom C++ container and I decided I would use this as an opportunity to learn some C++11 techniques and concepts, especially unique_ptr. Unfortunately I am having some trouble with the move semantics (I think) when inserting an element. Here is a very stripped down version of the code I am trying to get to compile:

#include <vector>
#include <memory>

struct Key {
    int k_;
    Key() : k_(0){};
    explicit Key(int k) : k_(k){};
    Key(const Key &o) : k_(o.k_) {}
    Key(Key &&o) { k_ = std::move(o.k_); }

    Key &operator=(const Key &o) {
        k_ = o.k_;
        return *this;
    }
    Key &operator=(Key &&o) {
        k_ = std::move(o.k_);
        return *this;
    }
    int get() const { return k_; }
};

template <class T> class CustomContainer {
public:
    typedef std::pair<Key, std::unique_ptr<Key>> Record;

    CustomContainer() {}
    ~CustomContainer(){};

    bool insert(const Record &record) {
        objects.emplace_back(std::move(record));
        return true;
    }
    std::vector<Record> objects;
};

int main() {
    CustomContainer<Key> q;
    q.insert(CustomContainer<Key>::Record(Key(1), std::unique_ptr<Key>(new Key(1))));
}

I am inserting a pointer to a Key object to keep the code simple. In my actual application, Key is a little more complicated, T is not Key, and the Custom container has many more member functions, but this is enough to highlight the problem. When I just have a unique_ptr object in the vector, everything appears to work just fine. As soon as I add the pair, I get:

/usr/bin/../lib/gcc/x86_64-linux-gnu/4.9/../../../../include/c++/4.9/ext/new_allocator.h:120:23: error: call to
      implicitly-deleted copy constructor of 'std::pair<Key, std::unique_ptr<Key, std::default_delete<Key> > >'
        { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
                             ^   ~~~~~~~~~~~~~~~~~~~~~~~~~~~
.
.
.

simple.cc:33:13: note: in instantiation of function template specialization 'std::vector<std::pair<Key,
      std::unique_ptr<Key, std::default_delete<Key> > >, std::allocator<std::pair<Key, std::unique_ptr<Key,
      std::default_delete<Key> > > > >::emplace_back<const std::pair<Key, std::unique_ptr<Key,
      std::default_delete<Key> > > >' requested here
    objects.emplace_back(std::move(record));
            ^
simple.cc:41:5: note: in instantiation of member function 'CustomContainer<Key>::insert' requested here
  q.insert(CustomContainer<Key>::Record(Key(1), std::unique_ptr<Key>(new Key(1))));

I tried the same thing with a custom class instead of a pair and got the same error. I can't seem to get the compiler to call the move constructor instead of the copy constructor no matter how many std::move()s I add. What am I missing?

I feel pretty dumb now. Yep, that is all it is. Thanks, Kerrek. If you want to add that as a formal answer, I'd be glad to accept it. — bsellersful, Oct 11 '15 at 16:30

score 0 · Accepted Answer · answered Oct 11 '15 at 16:29

0

you're passing a const ref to a unique_ptr and then trying to copy from it (you can only move from a non-const). Pass the entire object and then move from that. Since you're initialising with a temporary (r-value reference), there will be an implicit move at the call site.

patch to fix your code is here:

template <class T> class CustomContainer {
public:
   ...
    bool insert(Record record) { // <-- FIXED
       ...
    }
};

answered Oct 11 '15 at 16:29

Richard Hodges

68,278
7
90
142

Thanks, Richard. That is all it was. Turns out this is actually a duplicate of [this one](http://stackoverflow.com/questions/31413197/moving-a-vector-of-unique-ptrt?rq=1). Now that I see it the answer is obvious. – bsellersful Oct 11 '15 at 16:39
Obviously I don't need to tell you that a map in which the key is the same as the value is equivalent to a set... right? – Richard Hodges Oct 11 '15 at 16:49
Yes, Like I said I tried to simplify everything to where it wouldn't be too hard to look at. – bsellersful Oct 11 '15 at 17:17
:) a `unique_ptr` is very hard to look at... (i know, i know, it was an unfortunate substitution for the real thing). But it flags up something you should check out if you've not used c++ for a while. Have a look in the boost library for `boost::optional` when you have a moment. – Richard Hodges Oct 11 '15 at 18:47

Wrapping a unique_ptr with custom class in a container

1 Answers1