How to make Qt Signal emit by value without compile errors instead of reference?

Question

I read that the signal/slot concept in qt should always pass arguments by value instead of reference to ensure that signals/slots work flawlessly between threads.

I now have a piece of code that will only compile when the argument to a signal is emitted by reference, not value:

#include <QObject>

class mythirdclass {
public:
    mythirdclass();
};

class mysecondclass : public QObject, public mythirdclass {
public:
    mysecondclass(mythirdclass third);
};

class myclass : public QObject {
    Q_OBJECT
public:
    myclass();

signals:
    // not working
    void messageReceived(mysecondclass mymessage);
    // working
    // void messageReceived(mysecondclass &mymessage);
};

myclass::myclass()
{
    mythirdclass third;
    mysecondclass msg(third);
    emit messageReceived(msg);

}

mysecondclass::mysecondclass(mythirdclass third)
{
    // DO stuff
}

mythirdclass::mythirdclass()
{
}

The compiler error is:

..\example\main.cpp: In constructor 'myclass::myclass()':
..\example\main.cpp:28:20: error: use of deleted function 'mysecondclass::mysecondclass(const mysecondclass&)'
  emit signal(second);
                    ^
..\example\main.cpp:8:7: note: 'mysecondclass::mysecondclass(const mysecondclass&)' is implicitly deleted because the default definition would be ill-formed:
 class mysecondclass : QObject, public mythirdclass {
       ^

Based on the errors I thought abour writing a copy constructor for mysecondclass, however after some attempts I gave up for now, because I didn't get it right.

So my questions are:

why is the compiling failing in the first place?
if it fails because of a missing copy constructor, why is the compiler not able to define one implicitly?
how would the working copy constructor in my case look like?

Thanks in advance.

Your `mysecondclass` isn't inheriting `public QObject`... intentionally? — TrebledJ, Nov 22 '18 at 14:52
@JBL it is a minimal example. The real world scenario is `myclass` being a wrapper class that interfaces `QCanBusDevice` and `QCanBusFrame`. `mythirdclass` is a `QCanBusFrame` and `mysecondclass` is a specific message class that I use anywhere on the application layer. — darkmattercoder, Nov 22 '18 at 17:30
This is relevant: https://stackoverflow.com/q/26422154/1421332 — Silicomancer, Nov 23 '18 at 00:29

score 4 · Accepted Answer · answered Nov 22 '18 at 15:54

Why is the compiling failing in the first place?

Because passing by value implies copying, and if the copy-constructor is deleted, then it simply can't pass by value and your function cannot be compiled with this signature, while it can receive its argument by reference because it doesn't involve copying.

If it fails because of a missing copy constructor, why is the compiler not able to define one implicitly?

It actually fails because it hasn't been able to define one implicitly. The reason for that is that your class derives from QObject. And that QObject doesn't have a public or protected copy-constructor, by design. So the compiler cannot define one implicitly.

How would the working copy constructor in my case look like?

Given the nature of QObjects, and the design decision that's behind it when it comes to QObjects not being copyable, I would recommend against using signals and slots that take QObjects or class deriving from it by value (or simply any function that does this, and signals/slots are mainly functions deep down), but instead by reference or by pointer.

thanks for the deep explanation! I will go by reference, as long as I do not experience any issues that are related to signal emitting and multi-threading. — darkmattercoder, Nov 22 '18 at 17:27

score 0 · Answer 2 · answered Nov 22 '18 at 12:50

For you third question, if you do not want to define a default constructor for mysecondclass, your copy constructor would probably look like

 mysecondclass(mysecondclass const &other) : mythirdclass() {
    /// stuff
 }

For your second question, I suppose (not sure) that the default copy constructor try to use the default constructor that has been automatically deleted because you have defined another constructor of mysecondclass from an object of mythirdclass (I would recommend to you to use a const reference for the parameter here to avoid a useless copy)

Thanks for the hint regarding the `const&`, I'll change the constructor to a `mysecondclass::mysecondclass(const thirdclass &third)`. I also add a default constructor, just forgot it. The presence of such a `mysecondclass::mysecondclass()` however won't change the compile error. — darkmattercoder, Nov 22 '18 at 13:07

How to make Qt Signal emit by value without compile errors instead of reference?

2 Answers2