Is there any way to set a class in the QMap value?

Question

Is there any way to add & use a class in the QMap value?

I wanna use QMap<QString, Aclass> map; in Qt. and when I want to set it's value in a function, some errors appear:

C:\Qt\Qt5.5.0\5.5\mingw492_32\include\QtCore\qglobal.h:1043: error: 'QWidget& QWidget::operator=(const QWidget&)' is private
     Class &operator=(const Class &) Q_DECL_EQ_DELETE;
            ^

ps: my container class is inherited from QWidget & is singleton.

#include "Aclass.h"
#include <QWidget>

class AmainClass : public QWidget
{
    Q_OBJECT

public:
    static AmainClass &getInstance();
    void setApp(QString name, Aclass app);

private:
    AmainClass(QWidget *parent = 0);
    QMap<QString, Aclass> map;
};

and in .cpp:

void AmainClass::setApp(QString name, Aclass app)
{
    map.insert(name, app);
}

edit: Aclass is another class that is inherited from QWidget.

Answer 1

All Qt Objects that are derivated from QObject cannot be copied, because the copy constructor is private. This is the error message. You could use a reference or a pointer to your object in the map

QMap<QString, Aclass&> map;

or

QMap<QString, Aclass*> map;

Then the set function should be

void setApp(QString name, Aclass& app){
map.insert(name, app);
}

When you use pointers just replace & with *

Answer 2

As per Qt documentation, QObject and classes derived from it do not support being copied: Qt's meta-object mechanism and similar infrastructure relies on pointers to QObjects remaining valid, which would not hold if they were copied or moved around. You therefore cannot store a QObject in a container by value. Use a smart pointer instead:

QMap<QString, std::unique_ptr<Aclass>> map;

The same applies to setApp as well, of course:

void AmainClass::setApp(QString name, std::unique_ptr<Aclass> app)
{
    map.insert(name, std::move(app));
}

Using a std::unique_ptr assumes three things:

1. You are using a compiler which supports that part of C++11.
2. Your version of Qt is recent enough to support move semantics.
3. You intend map to be the sole owner of the Aclass objects.

Since this is 2016, 1 & 2 should really be true by now.

As for 3, you generally need to sort out ownership (a design decision) before you choose how to implement it (a coding decision). Based on your original example, I assume you want map to own the Aclass objects, hence my use of std::unique_ptr.

If you instead want to use a different ownership scheme (such as using Qt's parent-child ownership relationships), you'd use different storage. For the parent-child thing, a raw pointer (or perhaps QPointer) would be appropriate.

Answer 3

You can use std::reference_wrapper<Aclass> as a type for value.
Be aware anyway that you must guarantee for the lifetime of the referenced objects. See the documentation for further details.

Otherwise, you can use smart pointers like std::unique_ptr<Aclass> or std::shared_ptr<Aclass>, so that lifetime will be automatically managed for you.
See here for further details about shared_ptr, here for unique_ptr.

Otherwise, far simpler, you can define the missed operator operator= for Aclass. How almost depends on your actual problem, I cannot even say if it's a viable solution.