How to store an instance of QPropertyChangeHandler?

QProperty::onValueChange() returns a QPropertyChangeHandler object which I believe should be stored as a member variable so it will not be destroyed and consequently de-registering the Functor.

Since QPropertyChangeHandler is a Template class that takes a Functor, I need to provide the type of Functor that I am going to use but I am not sure what type to place there.

How should I store the returned QPropertyChangeHandler object?

The following are my best attempt so far:

Proptest.h

#ifndef PROP_TEST
#define PROP_TEST

#include <QObject>
#include <QProperty>
#include <QString>
#include <QPropertyChangeHandler>
#include <functional>

class PropTest : public QObject {
    Q_OBJECT

public:
    QProperty<QString> m_property;

    PropTest();
    ~PropTest() = default;

    // QString m_property;

    QPropertyChangeHandler< std::function<void()> > propertyChangeHandler;

    void TestFunction();
};

#endif

Proptest.cpp

#include <QObject>
#include <QString>
#include <QDebug>
#include <QApplication>

#include "prop_test.h"

PropTest::PropTest() { // <- error occurs here
    this->propertyChangeHandler = this->m_property.onValueChanged(&PropTest::TestFunction);
}

void PropTest::TestFunction() {
    // further processing
}

int main(int arc, char* argv[]) {

    auto app = QApplication(arc, argv);

    auto ob = new PropTest{};

    ob->m_property = "String";
    ob->m_property = "New";

    app.exec();
}

But all I got was this unfamiliar error:

[build] prop_test.cpp: In constructor 'PropTest::PropTest()':
[build] prop_test.cpp:11:20: error: no matching function for call to 'QPropertyChangeHandler<std::function<void()> >::QPropertyChangeHandler()'
[build]    11 | PropTest::PropTest() {
[build]       |                    ^

and I find the place where the error occurs bizarre.

Let us proceed in order.<br/>Disclaimer: unfortunately, I made the mistake of downloading a non-English version of Visual studio and never changed it back so I do not have the exact error messages.

The first error you sould have notice is in the lines of QPropertyChangeHandler<[...]> has no default constructor.

This is easily corrected by moving

this->propertyChangeHandler = this->m_property.onValueChanged(&PropTest::TestFunction);

out of the constructor's body and into the initialization list of your class.

With that error out of the way, it is time to solve the type mess.

The exact type of the PropTest::TestFunction method is void(PropTest::*)(); this is a different type from void() because inherently, for class' methods, the pointer this is always going to be an argument.

Because this is considered an argument, you cannot do:

propertyChangeHandler(m_property.onValueChanged(&PropTest::TestFunction))

If you try, you get the error message from Qt (from a static assert in QProperty.h): Functor callback must be callable without any parameters.

Assuming the function you want to connect in the handler needs to be an object method (not a separate function, not a static method), there are several ways to solve this:

1. First solution uses a functor, with your object as its member.<br/>Header:

   class PropTest;
   
   struct TestFunctor {
   public:
       TestFunctor(PropTest* propTestObject);
       void operator () () const;
   
   private:
       PropTest* object;
   
   };
   

   And source:

   TestFunctor::TestFunctor(PropTest* propTestObject)
       : object(propTestObject)
   {
   }
   void TestFunctor::operator()() const {
       object->TestFunction();
   }
   

   With that solution (and that solution only), the type of propertyChangeHandler must be changed to QPropertyChangeHandler<TestFunctor> and it is constructed with<br/>propertyChangeHandler( m_property.onValueChanged(TestFunctor(this))).

2. Second solution is to use a lambda. For instance:

   PropTest::PropTest()
       : QObject(),
       propertyChangeHandler(m_property.onValueChanged(std::function<void()>([=]() { this->TestFunction(); })))
   {
   }
   

   The type of propertyChangeHandler is QPropertyChangeHandler< std::function<void()> > if you decide to proceed this way (i.e. same as your question).

3. Third solution is to bind the TestFunction method.

   PropTest::PropTest()
       : QObject(),
       propertyChangeHandler(m_property.onValueChanged(std::function<void()>(std::bind(&PropTest::TestFunction, this))))
   {
   }
   

4. If you can turn the class method TestFunction() into a separate function or into a static method, it simplifies the issue quite a bit. The type of propertyChangeHandler needs to be, respectively QPropertyChangeHandler<void()> (for a separate function) or QPropertyChangeHandler<void(*)()> (for a static method).

And finally, it compiles!!

PS: If the function does not need to be attached to an object instance, I would use solution 4. Otherwise, I would go for either solution 2 or solution 3.