Qt源码解析3-信号和槽机制-QMetaType（qRegisterMetaType、Q_DECLARE_METATYPE、qMetaTypeId）

最新推荐文章于 2024-06-26 19:30:57 发布
最新推荐文章于 2024-06-26 19:30:57 发布
阅读量2.4k 收藏 8
点赞数 3
分类专栏： Qt 文章标签： c++ 开发语言 qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinqingwuji/article/details/123557682
版权

Qt源码解析 索引

目录

Qt源码解析 索引

类QMetaType

辅助类QtMetaTypePrivate

成员函数qMetaTypeId

成员函数type

成员函数create

成员函数destroy

相关宏Q_DECLARE_METATYPE

相关非成员函数qRegisterMetaType

类QMetaType

该类用作在 QVariant 以及排队的信号和槽连接中编组类型的帮助程序。它将类型名称与类型相关联，以便可以在运行时动态创建和销毁类型。使用 Q_DECLARE_METATYPE（） 声明新类型，使其可用于 QVariant 和其他基于模板的函数。调用 qRegisterMetaType（） 以使类型可用于非基于模板的函数，例如排队信号和插槽连接。

可以注册具有公有默认构造函数、公有复制构造函数和公有析构函数的任何类或结构。

下面的代码分配并销毁 MyClass 的实例：

int id = QMetaType::type("MyClass");//没有注册的类型获取为空
if (id != QMetaType::UnknownType) {
    void *myClassPtr = QMetaType::create(id);
    ...
    QMetaType::destroy(id, myClassPtr);
    myClassPtr = 0;
}

如果我们希望流运算符运算符<<（） 和运算符>>（） 处理存储自定义类型的 QVariant 对象，则自定义类型必须提供运算符<<（） 和运算符>>（） 运算符。

辅助类QtMetaTypePrivate

namespace QtMetaTypePrivate {
template <typename T, bool Accepted = true>
struct QMetaTypeFunctionHelper {
    static void Destruct(void *t)
    {
        Q_UNUSED(t) // Silence MSVC that warns for POD types.
        static_cast<T*>(t)->~T();
    }
​
    static void *Construct(void *where, const void *t)
    {
        if (t)
            return new (where) T(*static_cast<const T*>(t));
        return new (where) T;/*new表达式调用适当的分配函数分配存储，where类型如果是非数组类型，那么调用operator new。若是数组类型，则函数名为operator new[]。此处是布置new，若提供了布置参数，则将他们作为额外实参传递给分配函数。这些分配函数都被称为“布置 new”,这来源于标准分配函数void *operator new(std::size_t, void *).它直接返回未修改的第二个实参*/
    }
    ....
};

成员函数qMetaTypeId

在编译时返回类型 T 的元类型 ID。如果未使用 Q_DECLARE_METATYPE（） 声明类型，则编译将失败。

典型用法：

int id = qMetaTypeId<QString>();    // id is now QMetaType::QString
id = qMetaTypeId<MyStruct>();       // compile error if MyStruct not declared
/*判断语句为Q_STATIC_ASSERT_X(QMetaTypeId2<T>::Defined, "Type is not registered, please use the Q_DECLARE_METATYPE macro to make it known to Qt's meta-object system");
    */

QMetaType：：type（） 返回与 qMetaTypeId（） 相同的 ID，但会根据类型的名称在运行时进行查找。QMetaType：：type（） 有点慢，但如果未注册类型，编译会成功。

成员函数type

​
template <bool tryNormalizedType>
static inline int qMetaTypeTypeImpl(const char *typeName, int length)
{
    if (!length)
        return QMetaType::UnknownType;
    int type = qMetaTypeStaticType(typeName, length);
    if (type == QMetaType::UnknownType) {
        QReadLocker locker(customTypesLock());
        type = qMetaTypeCustomType_unlocked(typeName, length);
#ifndef QT_NO_QOBJECT
        if ((type == QMetaType::UnknownType) && tryNormalizedType) {
            const NS(QByteArray) normalizedTypeName = QMetaObject::normalizedType(typeName);
            type = qMetaTypeStaticType(normalizedTypeName.constData(),
                                       normalizedTypeName.size());
            if (type == QMetaType::UnknownType) {
                type = qMetaTypeCustomType_unlocked(normalizedTypeName.constData(),
                                                    normalizedTypeName.size());
            }
        }
#endif
    }
    return type;
}
int QMetaType::type(const char *typeName)
{
    return qMetaTypeTypeImpl</*tryNormalizedType=*/true>(typeName, qstrlen(typeName));
}
​

qMetaTypeStaticType内置类型存储在静态变量

static const struct { const char * typeName; int typeNameLength; int type; } types[] = {
    QT_FOR_EACH_STATIC_TYPE(QT_ADD_STATIC_METATYPE)
    QT_FOR_EACH_STATIC_ALIAS_TYPE(QT_ADD_STATIC_METATYPE_ALIASES_ITER)
    QT_FOR_EACH_STATIC_HACKS_TYPE(QT_ADD_STATIC_METATYPE_HACKS_ITER)
    {0, 0, QMetaType::UnknownType}
};

中。

qMetaTypeCustomType_unlocked自定义类型存储

const QVector<QCustomTypeInfo> * const ct = customTypes();
//全局静态变量定义
Q_GLOBAL_STATIC(QVector<QCustomTypeInfo>, customTypes)

成员函数create

void *QMetaType::create(int type, const void *copy)
{
    QMetaType info(type);
    if (int size = info.sizeOf())
        return info.construct(operator new(size), copy);//调用辅助类的构造函数
    return 0;
}

成员函数destroy

void QMetaType::destroy(int type, void *data)
{
    QMetaType info(type);
    info.destruct(data);//调用辅助类的析构函数
    operator delete(data);//清空创建对象大小的指针。
}

相关宏Q_DECLARE_METATYPE

#define Q_DECLARE_METATYPE(TYPE) Q_DECLARE_METATYPE_IMPL(TYPE)
#define Q_DECLARE_METATYPE_IMPL(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 (const int id = metatype_id.loadAcquire())           \
                    return id;                                          \
                const int newId = qRegisterMetaType< TYPE >(#TYPE,      \
                              reinterpret_cast< TYPE *>(quintptr(-1))); \
                metatype_id.storeRelease(newId);                        \
                return newId;                                           \
            }                                                           \
    };                                                                  \
    QT_END_NAMESPACE

Q_DECLARE_METATYPE 展开后是一个特化后的类 QMetaTypeId<TYPE>，特化的struct QMetaTypeId< TYPE > 调用qRegisterMetaType 函数将类型注册到MetaType 系统中

  • 如果要使自定义类型或其他非QMetaType内置类型在QVaiant中使用，必须使用该宏。

  • 该类型必须有公有的 构造、析构、复制构造 函数

相关非成员函数qRegisterMetaType

template <typename T>
int qRegisterNormalizedMetaType(const QT_PREPEND_NAMESPACE(QByteArray) &normalizedTypeName
#ifndef Q_CLANG_QDOC
    , T * dummy = 0
    , typename QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::DefinedType defined = QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::Defined
#endif
)
{
#ifndef QT_NO_QOBJECT
    Q_ASSERT_X(normalizedTypeName == QMetaObject::normalizedType(normalizedTypeName.constData()), "qRegisterNormalizedMetaType", "qRegisterNormalizedMetaType was called with a not normalized type name, please call qRegisterMetaType instead.");
#endif
    const int typedefOf = dummy ? -1 : QtPrivate::QMetaTypeIdHelper<T>::qt_metatype_id();
    if (typedefOf != -1)
        return QMetaType::registerNormalizedTypedef(normalizedTypeName, typedefOf);

    QMetaType::TypeFlags flags(QtPrivate::QMetaTypeTypeFlags<T>::Flags);

    if (defined)
        flags |= QMetaType::WasDeclaredAsMetaType;

    const int id = QMetaType::registerNormalizedType(normalizedTypeName,
                                   QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Destruct,
                                   QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Construct,
                                   int(sizeof(T)),
                                   flags,
                                   QtPrivate::MetaObjectForType<T>::value());

    if (id > 0) {
        QtPrivate::SequentialContainerConverterHelper<T>::registerConverter(id);
        QtPrivate::AssociativeContainerConverterHelper<T>::registerConverter(id);
        QtPrivate::MetaTypePairHelper<T>::registerConverter(id);
        QtPrivate::MetaTypeSmartPointerHelper<T>::registerConverter(id);
    }

    return id;
}

template <typename T>
int qRegisterMetaType(const char *typeName
#ifndef Q_CLANG_QDOC
    , T * dummy = nullptr
    , typename QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::DefinedType defined = QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::Defined
#endif
)
{
#ifdef QT_NO_QOBJECT
    QT_PREPEND_NAMESPACE(QByteArray) normalizedTypeName = typeName;
#else
    QT_PREPEND_NAMESPACE(QByteArray) normalizedTypeName = QMetaObject::normalizedType(typeName);
#endif
    return qRegisterNormalizedMetaType<T>(normalizedTypeName, dummy, defined);
}

必须使用该函数的两种情况

  • 如果非QMetaType内置类型要在 Qt 的属性系统中使用

  • 如果非QMetaType内置类型要在 queued 信号与槽 中使用

道格拉斯范朋克
关注
专栏目录
QT宏详解Q_OBJECT、Q_PROPERTY、Q_CLASSINFO、Q_ENUM、SIGNAL、SLOT、Q_FOREACH、Q_DECLARE_INTERFACE
啊渊的专栏
10-27 584
Q_PROPERTY是Qt中用于声明对象属性的宏。它允许在C++类中定义属性，使得这些属性能够被Qt的元对象系统（Meta-Object System）识别。通过使用Q_PROPERTY宏，你可以将C++类的属性（成员变量）暴露给Qt的元对象系统，从而实现属性的动态查询、修改和通知。是 Qt 中用于将用户自定义数据类型（非 Qt 内置类型）注册到元对象系统的宏。通常，Qt 提供的信号与槽机制、属性系统等功能是基于元对象系统实现的。
Qt 线程间共享数据(qRegisterMetaType的使用)
Faith_yu的博客
11-22 5975
如果是自己定义的类型如果想使用signal/slot来传递的话，则没有这么简单。直接使用的话，会产生下面这种错误： QObject::connect: Cannot queue arguments of type 'TextAndNumber' (Make sure 'TextAndNumber' is registed using qRegisterMetaType().) 原因：当一
qt自定义类型 Q_DECLARE_METATYPE与qRegisterMetaType
03-14
如果要使自定义类型或其他非QMetaType内置类型在QVaiant中使用，必须使用该宏Q_DECLARE_METATYPE。 该类型必须有公有的 构造、析构、复制构造 函数 qRegisterMetaType 必须使用该函数的两种情况：1、如果非QMetaType内置类型要在 Qt 的属性系统中使用2、如果非QMetaType内置类型要在 queued 信号与槽 中使用。 资源中对于如何使用给出代码样例，可以直接运行。
<QT>qRegisterMetaType
热门推荐
wangzhiqian7hao的专栏
10-27 1万+
如果要在Qt信号槽中使用自定义类型，需要注意使用qRegisterMetaType对自定义类型进行注册，当然在不跨线程时使用自定义类型signal/slot来传递，可能不会出现什么问题；一旦涉及跨线程就很容易出错，回想下信号槽的作用就是用来对象与对象之间通信的，难免会跨线程，建议在使用自定义类型利用信号槽通信时，最好先通过qRegisterMetaType()将自定义类型进行注册，以免出错。 总...
Q_DECLARE_METATYPE与qRegisterMetaType学习（转自：http://hi.baidu.com/cyclone/blog/item/01108bd40599b00fa18）
lslxdx的专栏
03-05 3283
基本理解 Q_DECLARE_METATYPE 如果要使自定义类型或其他非QMetaType内置类型在QVaiant中使用，必须使用该宏。该类型必须有公有的 构造、析构、复制构造 函数 qRegisterMetaType 必须使用该函数的两种情况 如果非QMetaType内置类型要在 Qt 的属性系统中使用如果非QMetaType内置类型要在 queued 信号与槽 中使用
Qt::Q_DECLARE_METATYPE
云淡风轻
01-09 9559
简介这个宏用来注册一个类(含默认构造、默认析构、拷贝构造函数)为QMetaType类型 ，注册后的类型可以作为QVariant的自定义类型。 这个宏应该放在类或者结构体外面的下面，也可以放在一个非公用引用的头文件里，在每次使用QVariant的时候引用该头文件。 想在信号队列、槽、 QObject’s property system中使用该类型，还得用qRegisterMetaTyp
QT的qRegisterMetaType和qRegisterMetaType
TT的博客
03-22 2670
以下只为自己的问题记录 参考理解 qRegisterMetaType使用方法如下： 1、注册位置：在第一次使用此类链接跨线程的signal/slot之前，一般在当前类的构造函数中进行注册； 2、注册方法：在当前类的顶部包含：#include ，构造函数中加入代码：qRegisterMetaType(“Myclass”)； 3、Myclass的引用类型需单独注册：qRegisterMetaType(“Myclass&”)； Q_DECLARE_METATYPE 1、这个宏用来注册一个类(含默认构造、默
Q_DECLARE_METATYPE_qRegisterMetaType.rar
04-06
当我们在自定义结构体或类中使用`Q_DECLARE_METATYPE`时，Qt就能够识别这个类型，并允许在信号和槽之间进行传递。 例如，假设我们有一个自定义结构体`Person`： ```cpp struct Person { QString name; int age; ...
qregistermetatype和q_declare_metatype
09-06
qRegisterMetaType和Q_DECLARE_METATYPE是Qt框架中用于自定义类型的两个重要宏。 Q_DECLARE_METATYPE宏用于在Qt元对象系统中注册自定义类型。通常情况下，Qt可以自动识别和处理Qt自带的内置类型，但对于自定义类型...
Q_DECLARE_METATYPE
09-06
- *1* [Qt源码解析3-信号和槽机制-QMetaType（qRegisterMetaType、Q_DECLARE_METATYPE、qMetaTypeId）](https://blog.csdn.net/xinqingwuji/article/details/123557682)[target="_blank" data-report-click={"spm":...
浅谈Q_DECLARE_METATYPE
最新发布
威桑的博客
06-26 873
Q_DECLARE_METATYPE
Qt文档阅读笔记-qRegisterMetaType()的原理及其使用
IT1995的博客
08-27 7864
目录   官方介绍 博主栗子     官方介绍 调用这个函数去注册类型T，这个T要使用Q_DECLARE_METATYPE()进行声明，返回meta type id，如下： int id = qRegisterMetaType&lt;MyStruct&gt;(); 这个函数需要他在被调用时有完整的定义。如果是指针类型他需要有完整的定义。使用Q_DECLARE_OPAQUE_PO...
元类型之Q_DECLARE_METATYPE
Y673582465的专栏
05-31 1197
#include <QMetaType> #include <QDebug>struct Struct1 { int a; double b; };typedef struct { Struct1 s; int c; }Struct2;struct Struct3 { int a; double b; operator QVariant() co
57.Qt-qRegisterMetaType
抵抗时间扭曲，坚持做一件有意义的事
11-27 565
在定义信号槽的时候，传递的参数类型如果是自定义类型(自定义class类,或者enum类等), 并且涉及跨线程时,最好先通过qRegisterMetaType()将自定义类型进行注册，否则会报错: QObject::connect: Cannot queue arguments of type 'XXXXXXX' (Make sure 'ERROR_LEVEL' is registered us...
Qt：qRegisterMetaType为Qt信号和槽添加自定义参数类型
weixin_44110080的博客
08-25 1148
Qt：qRegisterMetaType为Qt信号和槽添加自定义参数类型
qRegisterMetaType 用法
唐顺才的博客
11-02 2304
注意：如果自定义类型中包含了指针成员，需要使用qRegisterMetaTypeStreamOperators进行注册。此外，在使用qRegisterMetaType注册类型之前，需要确保类型的定义已经被包含在头文件中。qRegisterMetaType是Qt中用于注册自定义类型的函数。它允许将自定义类型与Qt信号槽系统无缝集成，以便在信号槽传递过程中自动进行类型转换和传递。
Qt信号槽机制-传递自定义数据类型(qRegisterMetaType)
宁静致远的博客
08-24 8223
Qt信号槽机制-传递自定义数据类型qRegisterMetaType前言 前言 通过Qt内置的数据类型进行信号与槽参数传递很方便；如果是自己定义的类型如果想使用signal/slot来传递的话，则没有这么简单。直接使用的话，会产生下面这种错误： QObject::connect: Cannot queue arguments of type ‘MyClass’ (Make sure ‘MyClass’ is registed using qRegisterMetaType().) 原因：当一个signal被
Qt线程间信号槽传递自定义数据类型(qRegisterMetaType的使用)
《好好先生》专栏
05-18 1746
Qt线程间信号槽传递自定义数据类型(qRegisterMetaType的使用) #include <QMetaType> CFileDataModel::CFileDataModel(QObject *parent) : QAbstractItemModel(parent) { //初始化根节点 init(); //指针和引用类型的参数都...
【Qt之QMetaType】使用
FreeLikeTheWind的博客
11-09 1874
【Qt之QMetaType】使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

道格拉斯范朋克

播种花生牛奶自留田

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值