Qt信号槽使用结构体作为参数：Q_DECLARE_METATYPE和qRegisterMetaType的作用

struct _ColorBalance
{
    bool preserve_luminosity;
    int cyan_red[3];
    int magenta_green[3];
    int yellow_blue[3];
};
signals:
    void state_changed(_ColorBalance *color_balance);
connect(this, &ColorBalance::state_changed, pic, &Picture::ColorBalance);

Call this function to register the type T. T must be declared with Q_DECLARE_METATYPE(). Returns the meta type Id.
Example:
int id = qRegisterMetaType<MyStruct>();
This function requires that T is a fully defined type at the point where the function is called. For pointer types, it also requires that the pointed to type is fully defined. Use Q_DECLARE_OPAQUE_POINTER() to be able to register pointers to forward declared types.
After a type has been registered, you can create and destroy objects of that type dynamically at run-time.
To use the type T in QVariant, using Q_DECLARE_METATYPE() is sufficient. To use the type T in queued signal and slot connections, qRegisterMetaType<T>() must be called before the first connection is established.
Also, to use type T with the QObject::property() API, qRegisterMetaType<T>() must be called before it is used, typically in the constructor of the class that uses T, or in the main() function.
Q_DECLARE_METATYPE(Type)
This macro makes the type Type known to QMetaType as long as it provides a public default constructor, a public copy constructor and a public destructor. It is needed to use the type Type as a custom type in QVariant.
This macro requires that Type is a fully defined type at the point where it is used. For pointer types, it also requires that the pointed to type is fully defined. Use in conjunction with Q_DECLARE_OPAQUE_POINTER() to register pointers to forward declared types.
Ideally, this macro should be placed below the declaration of the class or struct. If that is not possible, it can be put in a private header file which has to be included every time that type is used in a QVariant.
Adding a Q_DECLARE_METATYPE() makes the type known to all template based functions, including QVariant. Note that if you intend to use the type in queued signal and slot connections or in QObject's property system, you also have to call qRegisterMetaType() since the names are resolved at runtime.
This example shows a typical use case of Q_DECLARE_METATYPE():
struct MyStruct
{
    int i;
    ...
};
Q_DECLARE_METATYPE(MyStruct)
If MyStruct is in a namespace, the Q_DECLARE_METATYPE() macro has to be outside the namespace:
namespace MyNamespace
{
    ...
}
Q_DECLARE_METATYPE(MyNamespace::MyStruct)
Since MyStruct is now known to QMetaType, it can be used in QVariant:
MyStruct s;
QVariant var;
var.setValue(s); // copy s into the variant
...
// retrieve the value
MyStruct s2 = var.value<MyStruct>();
Some types are registered automatically and do not need this macro:
Pointers to classes derived from QObject
QList<T>, QVector<T>, QQueue<T>, QStack<T>, QSet<T> or QLinkedList<T> where T is a registered meta type
QHash<T1, T2>, QMap<T1, T2> or QPair<T1, T2> where T1 and T2 are registered meta types
QPointer<T>, QSharedPointer<T>, QWeakPointer<T>, where T is a class that derives from QObject
Enumerations registered with Q_ENUM or Q_FLAG
Classes that have a Q_GADGET macro