Wie verwenden von SIGNAL-und SLOT-ohne Ableitung von QObject?

ODER andere Art und Weise zu formulieren, die meine Frage (obwohl es nicht mein problem lösen): 'QObject::QObject' cannot access private member declared in class 'QObject'

Brauche ich Signale und SLOTS Funktionalität in meiner Klasse, aber ich nehme an, es ist nicht möglich, ohne eine Ableitung von QObject?

class MyClass
{
signals:
   importantSignal();
public slots:
   importantSlot();
};

Scheint das Problem zu sein, ich brauche die Ableitung von QObject Signale und slots ... aber ich brauche den default contructor von MyClass. Aber ich kann nicht konstruieren, weil Sie die folgende Funktion von QObject:
Kein Copy-Konstruktor oder Zuweisungsoperator.

Habe viel versucht ...

Also meine Klasse soll so Aussehen:

#include <QObject>
class MyClass: public QObject
{
    Q_OBJECT
public:
    explicit MyClass(QObject *parent = 0); //autogenerated by qtcreator for QObject derived class
    MyClass(const MyClass * other);

signals:
    importantSignal();
public slots:
    importantSlot();
};

Muss ich die default contructor von MyClass.

Also gibt es irgendeine Möglichkeit vermeiden, die "'QObject::QObject' cannot access private member declared in class 'QObject'" Fehler?

Oder als alternative gibt es keine Möglichkeit, die Signale und slots ohne QObject?

Ich bin froh für jeden Rat.

InformationsquelleAutor der Frage 6e69636b6e616d65 | 2011-09-21

c++qobject qt qt-signals slot

Wenn Sie möchten, eine kopierbar Objekt mit QObject Funktionen, die Sie brauchen-Mitgliedschaft (durch Zeiger) und nicht als inheritence.

Können Sie ableiten einer Klasse Handler aus QObject wo Handler's slots nennen SomeInterface virtuelle Funktionen auf seine Eltern.

struct NonQObjectHandler {
    virtual ~ NonQObjectHandler () {}
    virtual void receive (int, float) = 0;
};

class Handler : public NonQObjectHandler {
    struct Receiver;
    std :: unique_ptr <Receiver> m_receiver;
    void receive (int, float); //NonQObjectHandler
public:
    Handler ();
    Handler (const Handler &); //This is what you're really after
};

class Handler :: Receiver : public QObject {
Q_OBJECT
private:
    NonQObjectHandler * m_handler;
private slots:
    void receive (int, float); //Calls m_handler's receive
public:
    Receiver (NonQObjectHandler *);
};

Handler :: Handler ()
: m_receiver (new Receiver (this))
{
}

Handler :: Handler (const Handler & old)
: m_receiver (new Receiver (this))
{
    //Copy over any extra state variables also, but
    //Receiver is created anew.
}

Handler :: Receiver :: Receiver (NonQObjectHandler * h)
: m_handler (h)
{
    connect (foo, SIGNAL (bar (int, float)), this, SLOT (receive (int, float)));
}

void Handler :: Receiver :: receive (int i, float f)
{
    m_handler -> receive (i, f);
}

InformationsquelleAutor der Antwort spraff

7

Wenn Sie möchten, zu implementieren event-driven-Funktionalität mittels der Signale/slots-Muster, aber nicht wollen, um die Arbeit innerhalb der Grenzen von Qt (D. H., Sie möchten mit Ihrer Klasse in der STL-Container, etc. erfordern, dass der copy-Konstruktoren), ich würde vorschlagen, mit Boost::signal.

Sonst, Nein, können Sie möglicherweise nicht, was Sie wollen, sind, ohne sich aus QObject da, die base-Klasse ist, was behandelt das Qt-runtime-Signale/slots-Funktionalität.

InformationsquelleAutor der Antwort Jason
2

Können Sie nicht verwenden Qt ' s signal/slot-Mechanismen ohne Verwendung QObject/Q_OBJECT.

Du theoretisch könnte eine dummy-QObject und schreiben Sie Sie in Ihre Klasse. Die dummy-würden dann vorn das Ablagefach Anrufe zu Ihrer Klasse. Führen Sie wahrscheinlich in Probleme mit der Lebensdauer-management, aus den Gründen, die Liz hat, beschreibt in Ihrem Kommentar.

InformationsquelleAutor der Antwort Tom Kerr
2

Seit Qt5 können Sie einfach eine Verbindung zu einem beliebigen Funktion
```
connect(&timer, &QTimer::finished,
        &instanceOfMyClass, &MyClass::fancyMemberFunction);
```
InformationsquelleAutor der Antwort ManuelSchneid3r

In Qt5, verwenden Sie QObject::connect zu verbinden signal mit slot:

/*
   QMetaObject::Connection QObject::connect(
    const QObject *sender,
    const char *signal,
    const char *method,
    Qt::ConnectionType type = Qt::AutoConnection) const;
 */

#include <QApplication>
#include <QDebug>
#include <QLineEdit>

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    QLineEdit lnedit;

    //connect signal `QLineEdit::textChanged` with slot `lambda function`
    QObject::connect(&lnedit, &QLineEdit::textChanged, [&](){qDebug()<<lnedit.text()<<endl;});

    lnedit.show();
    return app.exec();
}