Qt 自定义数据类型qRegisterMetaType Q_DECLARE_METATYPE 的使用 （附demo）

代码下载地址如下：https://download.csdn.net/download/flowerspring/11019182

如果要在Qt信号槽中使用自定义类型，需要注意使用qRegisterMetaType对自定义类型进行注册，当然在不跨线程时使用自定义类型signal/slot来传递，可能不会出现什么问题；一旦涉及跨线程就很容易出错，回想下信号槽的作用就是用来对象与对象之间通信的，难免会跨线程，建议在使用自定义类型利用信号槽通信时，最好先通过qRegisterMetaType()将自定义类型进行注册，以免出错。

总结qRegisterMetaType使用方法如下：
  1、注册位置：在第一次使用此类链接跨线程的signal/slot之前，一般在当前类的构造函数中进行注册；
  2、注册方法：在当前类的顶部包含：#include <QMetaType>，构造函数中加入代码：qRegisterMetaType<MyClass>("Myclass")；
  3、Myclass的引用类型需单独注册：qRegisterMetaType<MyClass>("Myclass&")；

----------------

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>();

----------------

如果是自己定义的类型如果想使用signal/slot来传递的话，则没有这么简单。直接使用的话，会产生下面这种错误：

QObject::connect: Cannot queue arguments of type 'TextAndNumber' (Make sure 'TextAndNumber' is registed using qRegisterMetaType().) 

原因：当一个signal被放到队列中（queued）时，它的参数(arguments)也会被一起一起放到队列中（queued起来），这就意味着参数在被传送到slot之前需要被拷贝、存储在队列中（queue）中；为了能够在队列中存储这些参数(argument)，Qt需要去construct、destruct、copy这些对象，而为了让Qt知道怎样去作这些事情，参数的类型需要使用qRegisterMetaType来注册（如错误提示中的说明）

步骤：(以自定义TextAndNumber类型为例）

自定一种类型，在这个类型的顶部包含：#include <QMetaType>

在类型定义完成后，加入声明：Q_DECLARE_METATYPE(TextAndNumber);

在main()函数中注册这种类型：qRegisterMetaType<TextAndNumber>("TextAndNumber");

如果还希望使用这种类型的引用，可同样要注册：qRegisterMetaType<TextAndNumber>("TextAndNumber&");

#include <QMetaType>     
//必须包含QMetaType，否则会出现下面错误：     
//error: expected constructor, destructor, or type conversion before ‘;’ token     
#include <QString>     
class TextAndNumber {     
public:     
    TextAndNumber();     
    TextAndNumber(int, QString);     
    int count();     
    QString text();     
private:     
    int m_count;     
    QString m_text;     
};     
Q_DECLARE_METATYPE(TextAndNumber);     
#endif // TEXTANDNUMBER_H    

int main(int argc, char *argv[])     
{     
QApplication app(argc, argv); 
    qRegisterMetaType<TextAndNumber>("TextAndNumber");     
    qRegisterMetaType<TextAndNumber>("TextAndNumber&");     
    TextDevice device;     
    TextThread foo("foo"), bar("bar");     
    QObject::connect(&foo, SIGNAL(writeText(TextAndNumber&)), &device, SLOT(write(TextAndNumber&)));     
    QObject::connect(&bar, SIGNAL(writeText(TextAndNumber&)), &device, SLOT(write(TextAndNumber&)));     

------------------------------

class BH {

public:

    BH() {

        value = 10;

    }

    int value;

};

Q_DECLARE_METATYPE(BH)

---

BH bh;

QVariant var = QVariant::fromValue(bh);

qDebug() << var.canConvert<BH>();

BH bh2 = var.value<BH>();

qDebug() << bh2.value;

------

基本理解

• Q_DECLARE_METATYPE
  • 如果要使自定义类型或其他非QMetaType内置类型在QVaiant中使用，必须使用该宏。
  • 该类型必须有公有的 构造、析构、复制构造 函数
• qRegisterMetaType 必须使用该函数的两种情况
  • 如果非QMetaType内置类型要在 Qt 的属性系统中使用
  • 如果非QMetaType内置类型要在 queued 信号与槽 中使用

二者关系

 

二者的代码：

• Q_DECLARE_METATYPE 展开后是一个特化后的类 QMetaTypeId<TYPE>

• qRegisterMetaType 将某类型注册中 MetaType 系统中

二者的联系：

• QMetaTypeId<TYPE>的类中的成员包含对qRegisterMetaType的调用

• 我们知道类中的成员函数并不一定会被调用(即，该宏并不确保类型被注册到MetaType)。

• 通过qRegisterMetaType可以确保类型被注册

两个qRegisterMetaType 的联系

• 无参的qRegisterMetaType函数会通过该成员调用带参数的qRegisterMetaType()

这两个东西真难理清，不妨看看源码吧。

Q_DECLARE_METATYPE

代码来源：src/corelib/kernel/qmetatype.h

#define Q_DECLARE_METATYPE(TYPE)                                        \
    QT_BEGIN_NAMESPACE                                                  \
    template <>                                                         \
    struct QMetaTypeId< TYPE >                                          \
    {                                                                   \
        enum { Defined = 1 };                                           \
        static int qt_metatype_id()                                     \
            {                                                           \
                static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); \
                if (!metatype_id)                                       \
                    metatype_id = qRegisterMetaType< TYPE >(#TYPE);     \
                return metatype_id;                                     \
            }                                                           \
    };                                                                  \
    QT_END_NAMESPACE

 

• 宏展开是一个在Qt的命名空间中的一个类模板的特化 QMetaTypeId<TYPE>

• 该类含一个enum和一个返回!QMetaType的id的成员函数

qRegisterMetaType(const char *typeName)

代码来源：src/corelib/kernel/qmetatype.h

template <typename T>
int qRegisterMetaType(const char *typeName)
{
    typedef void*(*ConstructPtr)(const T*);
    ConstructPtr cptr = qMetaTypeConstructHelper<T>;
    typedef void(*DeletePtr)(T*);
    DeletePtr dptr = qMetaTypeDeleteHelper<T>;

    return QMetaType::registerType(typeName, reinterpret_cast<QMetaType::Destructor>(dptr),
                                   reinterpret_cast<QMetaType::Constructor>(cptr));
}

• 该函数的核心就是调用了registerType 函数
• 两个Helper模板函数分别对构造和析构函数进行封装

registerType

代码来源：src/corelib/kernel/qmetatype.cpp

int QMetaType::registerType(const char *typeName, Destructor destructor, Constructor constructor)

函数功能：

• 根据类型名查找其MetaType类型，如果已存在，则直接返回;否则创建后返回。

• 创建一个 !QCustomTypeInfo 对象
• 该对象包含要类型的构造、析构信息，已经规范化后的类型名
• 该对象存入一个全局的!QVector中

qRegisterMetaType()

看manual，可以知道，qRegisterMetaType 还有一个无参的重载函数。

template <typename T>
inline int qRegisterMetaType()
{
    return qMetaTypeId(static_cast<T *>(0));
}

• 函数看起来和带参数的那个似乎区别很大(难道不是么？)。
• 手册中告诉我们，执行这个的时候，模板参数T必须用 Q_DECLARE_METATYPE() 声明过
• 能猜到原因吗？注意看前面 Q_DECLARE_METATYPE() 代码，
• 对了。类中的成员函数qt_metatype_id中包含对qRegisterMetaType(typeName)的调用

• 这儿就是辗转调用了这个带参数的qRegisterMetaType函数 

unregisterType(const char *typeName)

函数的作用是取消自己先前注册的某个metatype类型。

前面提到注册信息在一个全局的 QVector<QCustomTypeInfo>中，当取消注册的时候是怎么样的呢？直接删除Vector中相应的项么？源码告诉我们，不是的。

实际是查找到相应的项，清空该项的内容。

for (int v = 0; v < ct->count(); ++v)
 {
 if (ct->at(v).typeName == typeName)
 {
 QCustomTypeInfo &inf = (*ct)[v];
 inf.typeName.clear();
 inf.constr = 0;
 inf.destr = 0;
 inf.alias = -1;
 }
}