Qt信号之自定义数据类型

【1】为什么需要自定义数据类型？

内置类型毕竟很有局限性，否则为什么还需要类呢。总之，有时候，我们多么希望信号能发送自定义数据类型。

幸哉~ Qt是支持自定义信号，且自定义信号可以发送自定义数据类型的对象。

【2】使用方法（声明 和 注册自定义数据类型）

1）引入头文件：#include<QMetaType>

2）添加声明：利用宏 Q_DECLARE_METATYPE

3）注册：利用方法 qRegisterMetaType

【3】实例Demo

1.文件目录（为了更好的模拟现实项目的需求，示例程序逻辑比较复杂）

2.pro文件

 #-------------------------------------------------
 #
 # Project created by QtCreator --27T21::
 #
 #-------------------------------------------------

 QT       += core gui

 greaterThan(QT_MAJOR_VERSION, ): QT += widgets

 TARGET = CustomDataType
 TEMPLATE = app

 DEFINES += QT_DEPRECATED_WARNINGS

 SOURCES += main.cpp\
     MyDialog.cpp \
     MainWindow.cpp

 HEADERS  += \
     MyDialog.h \
     MainWindow.h

 FORMS    += \
     MyDialog.ui \
     MainWindow.ui

3.MyDialog.h（自定义数据类型CustomDataType，使用宏Q_DECLARE_METATYPE声明数据类型）

 #ifndef MYDIALOG_H
 #define MYDIALOG_H

 #include <QDialog>
 #include <QMetaType>

 namespace Ui
 {
     class MyDialog;
 }

 class CustomDataType
 {
 public:
     CustomDataType(int n = ) : m_nValue(n) {}
     ~CustomDataType() {}
     int getValue() const { return m_nValue; }
     void setValue(int nValue) { m_nValue = nValue; }

 private:
     int m_nValue;
 };

 class MyDialog : public QDialog
 {
     Q_OBJECT

 public:
     explicit MyDialog(QWidget *parent = );
     ~MyDialog();

 public slots:
     void onTextChanged(const QString &str);

 signals:
     void postData(const CustomDataType &data);

 protected:
     void closeEvent(QCloseEvent *event);

 private:
     Ui::MyDialog *m_pUI;
     CustomDataType m_data;
 };

 Q_DECLARE_METATYPE(CustomDataType)

 #endif // MYDIALOG_H

4.MyDialog.cpp（构造函数中利用qRegisterMetaType注册自定义数据类型）

 #include "MyDialog.h"
 #include "ui_MyDialog.h"

 MyDialog::MyDialog(QWidget *parent) :
     QDialog(parent),
     m_pUI(new Ui::MyDialog)
 {
     m_pUI->setupUi(this);
     qRegisterMetaType<CustomDataType>("CustomDataType");

     connect(m_pUI->lineEdit, &QLineEdit::textChanged, this, &MyDialog::onTextChanged);
 }

 MyDialog::~MyDialog()
 {
     if (m_pUI)
     {
         delete m_pUI;
         m_pUI = Q_NULLPTR;
     }
 }

 void MyDialog::closeEvent(QCloseEvent *event)
 {
     emit postData(m_data);
     QDialog::closeEvent(event);
 }

 void MyDialog::onTextChanged(const QString & str)
 {
     bool bOK = false;
     int nNumber = str.toInt(&bOK);
     bOK ? m_data.setValue(nNumber) : m_data.setValue(-);
 }

5.MainWindow.h（业务类中直接定义槽函数，利用自定义数据类型作为参数类型即可）

 #ifndef MAINWINDOW_H
 #define MAINWINDOW_H

 #include <QDebug>
 #include <QMainWindow>
 #include "MyDialog.h"

 namespace Ui
 {
     class MainWindow;
 }

 class MainWindow : public QMainWindow
 {
     Q_OBJECT

 public:
     explicit MainWindow(QWidget *parent = );
     ~MainWindow();

 public slots:
     void onPostData(const CustomDataType &data);
     void onPushButtonPress();

 private:
     MyDialog m_dialog;
     Ui::MainWindow *m_pUI;
 };

 #endif // MAINWINDOW_H

6.MainWindow.cpp（connect正常连接信号与槽，并定义槽函数）

 #include "MainWindow.h"
 #include "ui_mainwindow.h"

 MainWindow::MainWindow(QWidget *parent)
     : QMainWindow(parent)
     , m_pUI(new Ui::MainWindow)
 {
     m_pUI->setupUi(this);
     connect(&m_dialog, &MyDialog::postData, this, &MainWindow::onPostData);
     connect(m_pUI->pushButton, &QPushButton::pressed, this, &MainWindow::onPushButtonPress);
 }

 MainWindow::~MainWindow()
 {
     if (m_pUI)
     {
         delete m_pUI;
         m_pUI = Q_NULLPTR;
     }
 }

 void MainWindow::onPostData(const CustomDataType &data)
 {
     m_pUI->pushButton->setText(QString::number(data.getValue()));
 }

 void MainWindow::onPushButtonPress()
 {
     m_dialog.show();
 }

7.main.cpp

 #include "MainWindow.h"
 #include <QApplication>

 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv);
     MainWindow w;
     w.show();

     return a.exec();
 }

8.ui文件请自理。

【4】运行效果图

按顺序图1->图2->图3

图1：弹出主窗体，主窗体中央部位放置一个PushButton，点击PushButton后，弹出图2对话框。

图2：对话框中间放置一个LineEdit，编辑数值123456，然后关闭对话框。

图3：当图2对话框被关闭时，会发送信号，信号会附加自定义数据类型的数据对象。

主窗体的响应槽函数从自定义数据对象中获取值，然后刷新PushButton文本为设置的数据值。

【5】源码剖析

1）宏 Q_DECLARE_METATYPE

源码如下。摘自版本路径（C:\Qt\Qt5.7.1\5.7\msvc2013\include\QtCore\qmetatype.h）

 #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 =  };                                           \
         static int qt_metatype_id()                                     \
             {                                                           \
                 static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(); \
                 if (const int id = metatype_id.loadAcquire())           \
                     return id;                                          \
                 const int newId = qRegisterMetaType< TYPE >(#TYPE,      \
                               reinterpret_cast< TYPE *>(quintptr(-))); \
                 metatype_id.storeRelease(newId);                        \
                 return newId;                                           \
             }                                                           \
     };                                                                  \
     QT_END_NAMESPACE

 #ifndef Q_BASIC_ATOMIC_INITIALIZER
 #  define Q_BASIC_ATOMIC_INITIALIZER(a) { (a) }
 #endif

2) 模板函数qRegisterMetaType

源码如下。摘自版本路径（C:\Qt\Qt5.7.1\5.7\msvc2013\include\QtCore\qmetatype.h）

 template <typename T>
 int qRegisterMetaType(const char *typeName
 #ifndef Q_QDOC
     , T * dummy = Q_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);
 }

 template<typename T, bool defined>
 struct MetaTypeDefinedHelper
 {
     enum DefinedType { Defined = defined };
 };

 template <typename T>
 int qRegisterNormalizedMetaType(const QT_PREPEND_NAMESPACE(QByteArray) &normalizedTypeName
 #ifndef Q_QDOC
     , T * dummy =
     , 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 ? - : QtPrivate::QMetaTypeIdHelper<T>::qt_metatype_id();
     if (typedefOf != -)
         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 > )
     {
         QtPrivate::SequentialContainerConverterHelper<T>::registerConverter(id);
         QtPrivate::AssociativeContainerConverterHelper<T>::registerConverter(id);
         QtPrivate::MetaTypePairHelper<T>::registerConverter(id);
         QtPrivate::MetaTypeSmartPointerHelper<T>::registerConverter(id);
     }

     return id;
 }

详细内容。

Good Good Study，Day Day Up.

顺序 选择 循环 总结