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

最新推荐文章于 2023-11-24 23:06:13 发布
最新推荐文章于 2023-11-24 23:06:13 发布
阅读量2.1k 收藏 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 信号与槽 中使用

道格拉斯范朋克
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
qt自定义类型 Q_DECLARE_METATYPE与qRegisterMetaType
03-14
如果要使自定义类型或其他非QMetaType内置类型在QVaiant中使用，必须使用该宏Q_DECLARE_METATYPE。 该类型必须有公有的 构造、析构、复制构造 函数 qRegisterMetaType 必须使用该函数的两种情况：1、如果非QMetaType内置类型要在 Qt 的属性系统中使用2、如果非QMetaType内置类型要在 queued 信号与槽 中使用。 资源中对于如何使用给出代码样例，可以直接运行。
Qt中以qRegister开头的几个函数的用法说明
danshiming的博客
06-14 1132
Qt中以qRegister开头的几个函数的用法说明
error: C2338: Type is not registered, please use the Q_DECLARE_METATYPE macro to make it known to Qt
aoxuestudy的专栏
09-16 4551
error: C2338: Type is not registered, please use the Q_DECLARE_METATYPE macro to make it known to Qt's meta-object system 只提供公共默认构造函数、公共复制构造函数和公共析构函数，该宏就会使QMetaType知道类型类型类型。需要将类型类型类型用作QVariant中的自定义类型。 此宏要求类型在使用时是完全定义的类型。对于指针类型，还需要完全定义指向类型。与Q_DECLARE_OPAQU
Qt注册自定义类型
ken2232的博客
08-05 345
Qt注册自定义类型
Qt元类型（MetaType）
lubufan的博客
12-10 1759
文章目录Q_DECLARE_METATYPEqRegisterMetaType Q_DECLARE_METATYPE 使用Q_DECLARE_METATYPE标记自定义类型，可以让QMetaType查询到类型，也可以让QVariant识别。 #include <QMetaType> struct MyStruct { QString name; QString colo...
qRegisterMetaType用法总结
thanklife的专栏
11-23 7277
如果要在Qt信号槽中使用自定义类型，需要注意使用qRegisterMetaType对自定义类型进行注册，当然在不跨线程时使用自定义类型signal/slot来传递，可能不会出现什么问题；一旦涉及跨线程就很容易出错，回想下信号槽的作用就是用来对象与对象之间通信的，难免会跨线程，建议在使用自定义类型利用信号槽通信时，最好先通过qRegisterMetaType()将自定义类型进行注册，以免出错。
Qt文档阅读笔记-关于Q_DECLARE_METATYPE原理以及使用
热门推荐
IT1995的博客
08-26 3万+
  目录 官方解释 博主补充小栗子 最简单的关于Q_DECLARE_METATYPE的例子： 关于qRegisterMetaType的栗子   官方解释 Q_DECLARE_METATYPE(Type) 这个宏是为了让QMetaType知道Type这个数据类型，并提供一个默认的拷贝构造函数和析构函数。QVariant需要使用Q_DECLARE_METATYPE这个宏来定制类型。 ...
qRegisterMetaType 用法
唐顺才的博客
11-02 1175
注意：如果自定义类型中包含了指针成员，需要使用qRegisterMetaTypeStreamOperators进行注册。此外，在使用qRegisterMetaType注册类型之前，需要确保类型的定义已经被包含在头文件中。qRegisterMetaType是Qt中用于注册自定义类型的函数。它允许将自定义类型与Qt信号槽系统无缝集成，以便在信号槽传递过程中自动进行类型转换和传递。
Qt中以Q_DECLARE开头的几个宏的用法说明
danshiming的博客
05-30 1774
Q_DECLARE开头的几个宏的用法说明
Q_DECLARE_METATYPE_qRegisterMetaType.rar
04-06
Qt信号槽使用结构体作为参数 https://blog.csdn.net/libaineu2004/article/details/105332464
QT QSerialPort 封装，阻塞方式发送数据后等待读取缓冲区数据结果，使用QT信号量阻塞，线程中初始化串口和读取数据。
05-23
QT QSerialPort 封装，阻塞方式发送数据后等待读取缓冲区数据结果，使用QT信号量阻塞，线程中初始化串口和读取数据。
RabbitMQ客户端Qt工程文件
03-23
该RabbitMQ客户端是以QAMPQ为基础进行创建的测试工程，可直接编译通过，在各配置项中添加有详细备注，以方便理解该工程结构，也可以此工程结构进行RabbitMQ的Qt语言的相关项目开发。
Qt：QMetaType类
OceanStar的博客
04-10 4638
QMetaType类管理元对象系统中的命名类型 头文件： #include <QMetaType> qmake: find_package(Qt6 COMPONENTS Core REQUIRED) target_link_libraries(mytarget PRIVATE Qt6::Core) cmake: QT += core 注意：此类中的所有函数都是线程安全的。 详细说明 该类被用作在QVariant、队列信号和槽连接中marshall类型的助手。 QMetaType类管理Q
QT开发中自定义参数的qRegisterMetaType注册
最新发布
qq_40326539的博客
11-24 229
Qt中的类库有接近一半是从基类QObject上继承下来，信号与反应槽（signals/slot）机制就是用来在QObject类或其子类间通讯的方法（connect），当自定义参数如果出现如下错误提示的时候，表示你的参数可能没有进行注册：解决方法：在窗口程序中直接把写上如下代码即可（参数替换成自己的）
Qt qRegisterMetaType 注册元类型
qq_44720283的博客
08-11 254
注册元类型；QObject::connect: Cannot queue arguments of type 'MyType‘
Q_DECLARE_METATYPE和qRegisterMetaType
weixin_43047324的博客
12-20 628
解释一下Q_DECLARE_METATYPE和qRegisterMetaType的应用范围和用法，即回答了在什么情况下用，怎么用的问题
Qt::Q_DECLARE_METATYPE
云淡风轻
01-09 9440
简介这个宏用来注册一个类(含默认构造、默认析构、拷贝构造函数)为QMetaType类型 ，注册后的类型可以作为QVariant的自定义类型。 这个宏应该放在类或者结构体外面的下面，也可以放在一个非公用引用的头文件里，在每次使用QVariant的时候引用该头文件。 想在信号队列、槽、 QObject’s property system中使用该类型，还得用qRegisterMetaTyp
QComboBox 简介
xinqingwuji的博客
04-03 4905
详细说明 QComboBox小部件是一个组合按钮和弹出列表。 QComboBox提供了一种以占用最少屏幕空间的方式向用户显示选项列表的方法。 组合框是一个显示当前项目的选择小部件，可以弹出可选项目列表。组合框可以是可编辑的，允许用户修改列表中的每个项目。 组合框可以包含像素图和字符串; insertItem（）和setItemText（）函数适当重载。对于可编辑的组合框，提供了clearEditT...
qregistermetatype和q_declare_metatype
09-06
qRegisterMetaType和Q_DECLARE_METATYPE是Qt框架中用于自定义类型的两个重要宏。 Q_DECLARE_METATYPE宏用于在Qt元对象系统中注册自定义类型。通常情况下，Qt可以自动识别和处理Qt自带的内置类型，但对于自定义类型，我们需要使用Q_DECLARE_METATYPE宏进行注册。例如，如果我们有一个自定义类MyClass，我们可以在该类的头文件中使用Q_DECLARE_METATYPE宏进行声明，告诉Qt该类型存在。这样，在我们使用该类型的地方，Qt就可以正确处理。 qRegisterMetaType函数用于将自定义类型注册到Qt的元对象系统中，使得该类型可以在信号槽机制中传递。我们需要在程序运行前调用qRegisterMetaType函数来注册我们所需要使用的自定义类型。这样，在信号和槽的连接中，Qt就可以正确识别和处理我们自定义的类型。 总结起来，Q_DECLARE_METATYPE宏用于在编译时期告诉Qt某种类型存在，而qRegisterMetaType函数用于在运行时期将该类型注册到Qt的元对象系统中。这样，我们就可以在Qt的信号槽机制中使用自定义类型，实现更加灵活和强大的功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

道格拉斯范朋克

播种花生牛奶自留田

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

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

打赏作者

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

抵扣说明：

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

余额充值