Qt信号之自定义数据类型

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

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

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

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

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

2）添加声明：利用宏 Q_DECLARE_METATYPE

3）注册：利用方法 qRegisterMetaType

【3】实例Demo

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

2.pro文件

#-------------------------------------------------
#
# Project created by QtCreator 2017-06-27T21:34:46
#
#-------------------------------------------------

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): 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 = 100) : 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 = 0);
    ~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(-1);
}

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 = 0);
    ~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:QtQt5.7.15.7msvc2013includeQtCoreqmetatype.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 = 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

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

2) 模板函数qRegisterMetaType

源码如下。摘自版本路径（C:QtQt5.7.15.7msvc2013includeQtCoreqmetatype.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 = 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;
}

详细内容。

Good Good Study，Day Day Up.

顺序 选择 循环 总结