CODEWITHSUNDEEP
c++qtinheritancesignals-slots
kamal
kamal

Reputation: 59

Using signals into a class which is inheriting from QObject

I'm asking if there is a way to use signals in a class which inherits from QObject like this:

mysuperclass.cpp

#include "mysuperclass.h"

MySuperclass::MySuperclass(quint16 port, QObject *parent) :
  QObject(parent), port(port)
{
  this->connected = false;
}

mysuperclass.h

#include <QAbstractSocket>

class MySuperclass: public QObject
{
  Q_OBJECT
public:
  explicit MySuperclass(quint16 port = 0, QObject *parent = 0);

signals:
   //there is nothing here
public slots:
  virtual void newValue(){qDebug() << "newValue";}
  virtual void connectionEstablished(){qDebug() << "connectionEstablished";}
  virtual void disconnected(){qDebug() << "disconnected";}
protected:
  QAbstractSocket* networkSocket;
  quint16 port;
  bool connected;
};

mysubclass.cpp

#include <QTcpSocket>
#include <QHostAddress>

MySubClass::MySubClass(quint16 ServerPort, QObject *parent) : 
  MySuperClass(ServerPort, parent) 
{
  this->networkSocket = new QTcpSocket(this);
  ...
  connect(this->networkSocket, SIGNAL(connected()),this,
    SLOT(connectionEstablished()));
  connect(this->networkSocket, SIGNAL(disconnected()),this,
    SLOT(disconnected()));
  connect(this->networkSocket, SIGNAL(readyRead()),this, SLOT(newValue()));
}

mysubclass.h

#include <QObject>
#include "mysuperclass.h"

class MySubClass: public MySuperClass
{
 public:
   MySubClass(quint16 ServerPort, QObject* parent=0);

 public slots:
   void newValue();
   void connectionEstablished();
   void disconnected();
};

Upvotes: 2

Views: 2000

Answers (1)

cbuchart
cbuchart

Reputation: 11575

You must include the Q_OBJECT macro in the derived class too (but don't derive from QObject again). The macro is only mandatory if the derived class declares signals or slots. For emitting parent's signals or connecting with parent's slots it is not necessary (it also means that it is not necessary to re-define already existing signals or slots).

From Qt's documentation:

The Q_OBJECT macro must appear in the private section of a class definition that declares its own signals and slots or that uses other services provided by Qt's meta-object system.

Example

class MySubClass : public MySuperClass {
  Q_OBJECT

  public:
    MySubClass(quint16 ServerPort, QObject* parent=0);

  public slots:
    void newValue();
    void connectionEstablished();
    void disconnected();
};

On the other hand, if you want to connect to a slot in the parent class but implement it in a derived one, then you must make it virtual:

class MySuperclass : public QObject {
  Q_OBJECT
  // ...
public slots:
  virtual void newValue(); // can be virtual pure also
};

class MySubClass : public MySuperClass {
public:
  virtual void newValue() override; // overrides parent's
}

Note that there is no need to use the Q_OBJECT macro nor to use the slot: label in the derived class. Slots are normal methods after all. Of course, you have to use it if you add new slots or signals.

Upvotes: 7

Related Questions