QMap and std::unique_ptr

Question

I am trying to prevent naked pointers, to prevent memory leaking etc. I also want to map int to INuiSensor*. Since I am also using Qt I tried to use QMap<int, std::unique_ptr<INuiSensor>> to do this, but the source code of QMap makes this impossible:

template <class Key, class T>
Q_INLINE_TEMPLATE typename QMap<Key, T>::iterator QMap<Key, T>::insert(const Key &akey, const T &avalue)
{
    detach();
    Node *n = d->root();
    Node *y = d->end();
    Node *last = 0;
    bool  left = true;
    while (n) {
        y = n;
        if (!qMapLessThanKey(n->key, akey)) {
            last = n;
            left = true;
            n = n->leftNode();
        } else {
            left = false;
            n = n->rightNode();
        }
    }
    if (last && !qMapLessThanKey(akey, last->key)) {
        last->value = avalue;
        return iterator(last);
    }
    Node *z = d->createNode(akey, avalue, y, left);
    return iterator(z);
}

The line:

last->value = avalue;

Is the one that creates the problem: you cannot use the =operator directly on a unique_ptr. So now I am puzzeled on what to do next. Is it possible to use QMap and unique_ptr in some other way? Is the whole idea of using QMap and unique_ptr stupid for some reason? What can I do to prevent using naked pointers while still using a QMap?

Unknit

That's because Qt containers and Qt pointers are shit, frankly speaking. Use std::map, especially if you are already using std::unique_ptr. Or misuse QSharedPointer. – Petrography

@Petrography That's a strong statement, any evidence to back it up? – Fleta

@cmannett85, this one, QScopedPointer does not support move semantics, Qt containers consider taking an iterator as modification (that's why qvector.begin() is not thread safe), only unordered set, hash function implementation is tricky and you cannot specify one directly and so on. – Petrography

Answer 1

using Qt container, you should use Qt smart pointers implementation. More about the different implementations in this thread.

What C++ Smart Pointer Implementations are available?

as mentionned, you could go with QSharedPointer.

Licastro

The closest approximation to a unique_ptr in Qt would be QScopedPointer. But since it doesn't implement move semantics it is useless in all but the simplest use cases. – Lentissimo

Answer 2

Of course this isn't going to work, you have created a unique pointer and then you try to copy it into a QMap.

Use a QSharedPointer. When all references to the INuiSensor* instance have been deleted, the instance will be deleted.

Fleta

I am not trying to copy it into the qmap, I am std::moving it into the qmap. Problem is that the QMap them copies it into its internal datastructure, which is the actual problem. Thats why I am stating that the problem is in the QMap source code and not in my code(which doesn't mean its not my fault, but at least im smart enough to move a unique_ptr, and not just copy it). – Unknit

@Unknit Then you should have stated that in your question. – Fleta