QML与C++混合编程详解(QML与c++信号与槽的操作)

最新推荐文章于 2024-04-04 17:23:58 发布
最新推荐文章于 2024-04-04 17:23:58 发布
阅读量2.1k 收藏 28
点赞数 4
分类专栏： QT
原文链接：https://www.cnblogs.com/findumars/p/6090850.html
版权

1、QML与C++为什么要混合编程

QML与C++为什么要混合编程，简单来说，就是使用QML高效便捷地构建UI，而C++则用来实现业务逻辑和复杂算法，下面介绍了两者间交互的方法与技巧。

2、QML访问C++概述

Qt集成了QML引擎和Qt元对象系统，使得QML很容易从C++中得到扩展，在一定的条件下，QML就可以访问QObject派生类的成员，例如信号、槽函数、枚举类型、属性、成员函数等。

QML访问C++有两个方法：一是在Qt元对象系统中注册C++类，在QML中实例化、访问。二是在C++中实例化并设置为QML上下文属性，在QML中直接使用。与后者相比，前者可以使C++类在QML中作为一个数据类型，例如函数参数类型或属性类型，也可以使用其枚举类型、单例等，功能更强大。

3、如何实现可以被QML访问的C++类

C++类要想被QML访问，首先必须满足两个条件：一是派生自QObject类或QObject类的子类，二是使用Q_OBJECT宏。QObject类是所有Qt对象的基类，作为Qt对象模型的核心，提供了信号与槽机制等很多重要特性。Q_OBJECT宏必须在private区（C++默认为private）声明，用来声明信号与槽，使用Qt元对象系统提供的内容，位置一般在语句块首行。下面例子在QtCreator3.1.2中创建，Projects选择QtQuickApplication，工程名为Gemini，Component选择QtQuick2.2，然后在自动生成的文件中添砖加瓦。

信号与槽——

（1）添加头文件Gemini.h

#ifndef GEMINI_H  
#define GEMINI_H  
// Gemini.h  
#include <QObject>  
#include <QDebug>  
class Gemini : public QObject  
{  
    Q_OBJECT  
signals:  
    void begin();  
public slots:  
    void doSomething() {  
        qDebug() << "Gemini::doSomething() called";  
    }  
};  
#endif // GEMINI_

Gemini类中的信号begin()和槽doSomething()都可以被QML访问。槽必须声明为public或protected，信号在C++中使用时要用到emit关键字，但在QML中就是个普通的函数，用法同函数一样，信号处理器形式为on<Signal>，Signal首字母大写。信号不支持重载，多个信号的名字相同而参数不同时，能够被识别的只是最后一个信号，与信号的参数无关。

（2）修改main.cpp

    // main.cpp  
    #include <QGuiApplication>  
    #include <QQmlApplicationEngine>  
    #include <QtQml>  
    #include <Gemini.h>  
    int main(int argc, char *argv[])  
    {  
        QGuiApplication app(argc, argv);  
        qmlRegisterType<Gemini>("Union.Lotto.Gemini", 1, 0, "Gemini");  
        QQmlApplicationEngine engine;  
        engine.load(QUrl(QStringLiteral("qrc:///main.qml")));  
        return app.exec();  
    }

 

这里把Gemini类注册（qmlRegisterType）到了Qt元对象系统，当然也可以先实例化再设置为QML上下文属性，相关内容将在后面详细介绍。

（3）修改main.qml

// main.qml  
import QtQuick 2.2  
import QtQuick.Window 2.1  
import Union.Lotto.Gemini 1.0  
Window {  
    visible: true  
    width: 360; height: 360  
    title: "Union Lotto Game"  
    color: "white"  
    MouseArea {  
        anchors.fill: parent  
        onClicked: {  
            gemini.begin()  
        }  
    }  
    Gemini {  
        id: gemini  
        onBegin: doSomething()  
    }  
}

Gemini类注册到Qt元对象系统后，并且在QML文件中导入（import），关键字Gemini就可以在当前QML文件中当作一种QML类型来用了。例子中有个MouseArea，单击鼠标时会发送begin()信号，进而调用doSomething()槽函数。

枚举类型——

（1）修改头文件Gemini.h

#ifndef GEMINI_H  
#define GEMINI_H  
// Gemini.h  
#include <QObject>  
#include <QDebug>  
class Gemini : public QObject  
{  
    Q_OBJECT  
    Q_ENUMS(BALL_COLOR)  
public:  
    Gemini() : m_ballColor(BALL_COLOR_YELLOW) {  
        qDebug() << "Gemini::Gemini() called";  
    }  
    enum BALL_COLOR {  
        BALL_COLOR_YELLOW,  
        BALL_COLOR_RED,  
        BALL_COLOR_BLUE,  
        BALL_COLOR_ALL  
    };  
signals:  
    void begin();  
public slots:  
    void doSomething(BALL_COLOR ballColor) {  
        qDebug() << "Gemini::doSomething() called with" << ballColor;  
        if(ballColor != m_ballColor) {  
            m_ballColor = ballColor;  
            qDebug() << "ball color changed";  
        }  
    }  
private:  
    BALL_COLOR m_ballColor;  
};  
#endif // GEMINI_H

Gemini类中添加了public的BALL_COLOR枚举类型，这个枚举类型要想在QML中使用，就用到了Q_ENUMS()宏。

（2）修改main.qml


    // main.qml  
    import QtQuick 2.2  
    import QtQuick.Window 2.1  
    import Union.Lotto.Gemini 1.0  
    Window {  
        visible: true  
        width: 360; height: 360  
        title: "Union Lotto Game"  
        color: "white"  
        MouseArea {  
            anchors.fill: parent  
            onClicked: {  
                gemini.begin()  
            }  
        }  
        Gemini {  
            id: gemini  
            onBegin: doSomething(Gemini.BALL_COLOR_RED)  
        }  
    }

 

在QML中使用枚举类型的方式是<CLASS_NAME>.<ENUM_VALUE>，例如Gemini.BALL_COLOR_RED。

成员函数——

（1）修改头文件Gemini.h

[cpp] view plain copy

 

#ifndef GEMINI_H  
#define GEMINI_H  
// Gemini.h  
#include <QObject>  
#include <QDebug>  
class Gemini : public QObject  
{  
    Q_OBJECT  
    Q_ENUMS(BALL_COLOR)  
public:  
    Gemini() : m_ballColor(BALL_COLOR_YELLOW) {  
        qDebug() << "Gemini::Gemini() called";  
    }  
    enum BALL_COLOR {  
        BALL_COLOR_YELLOW,  
        BALL_COLOR_RED,  
        BALL_COLOR_BLUE,  
        BALL_COLOR_ALL  
    };  
    Q_INVOKABLE void stop() {  
        qDebug() << "Gemini::stop() called";  
    }  
signals:  
    void begin();  
public slots:  
    void doSomething(BALL_COLOR ballColor) {  
        qDebug() << "Gemini::doSomething() called with" << ballColor;  
        if(ballColor != m_ballColor) {  
            m_ballColor = ballColor;  
            qDebug() << "ball color changed";  
        }  
    }  
private:  
    BALL_COLOR m_ballColor;  
};  
#endif // GEMINI_H

 

Gemini类中添加了成员函数stop()，在QML中访问的前提是public或protected成员函数，且使用Q_INVOKABLE宏，位置在函数返回类型的前面。

（2）修改main.qml

[plain] view plain copy

// main.qml  
import QtQuick 2.2  
import QtQuick.Window 2.1  
import Union.Lotto.Gemini 1.0  
Window {  
    visible: true  
    width: 360; height: 360  
    title: "Union Lotto Game"  
    color: "white"  
    MouseArea {  
        anchors.fill: parent  
        onClicked: {  
            gemini.begin()  
            gemini.stop()  
        }  
    }  
    Gemini {  
        id: gemini  
        onBegin: doSomething(Gemini.BALL_COLOR_RED)  
    }  
}

在QML中访问C++的成员函数的形式是<id>.<method>，例如gemini.stop()。支持函数重载，这个与信号不同。

C++类的属性——

（1）修改头文件Gemini.h

[cpp] view plain copy

 

#ifndef GEMINI_H  
#define GEMINI_H  
// Gemini.h  
#include <QObject>  
#include <QDebug>  
class Gemini : public QObject  
{  
    Q_OBJECT  
    Q_ENUMS(BALL_COLOR)  
    Q_PROPERTY(unsigned int ballNumber READ ballNumber WRITE setBallNumber NOTIFY ballNumberChanged)  
public:  
    Gemini() : m_ballColor(BALL_COLOR_YELLOW), m_ballNumber(0) {  
        qDebug() << "Gemini::Gemini() called";  
    }  
    enum BALL_COLOR {  
        BALL_COLOR_YELLOW,  
        BALL_COLOR_RED,  
        BALL_COLOR_BLUE,  
        BALL_COLOR_ALL  
    };  
    unsigned int ballNumber() const {  
        return m_ballNumber;  
    }  
    void setBallNumber(const unsigned int &ballNumber) {  
        if(ballNumber != m_ballNumber) {  
            m_ballNumber = ballNumber;  
            emit ballNumberChanged();  
        }  
    }  
    Q_INVOKABLE void stop() {  
        qDebug() << "Gemini::stop() called";  
    }  
signals:  
    void begin();  
    void ballNumberChanged();  
public slots:  
    void doSomething(BALL_COLOR ballColor) {  
        qDebug() << "Gemini::doSomething() called with" << ballColor;  
        if(ballColor != m_ballColor) {  
            m_ballColor = ballColor;  
            qDebug() << "ball color changed";  
        }  
    }  
private:  
    BALL_COLOR m_ballColor;  
    unsigned int m_ballNumber;  
};  
#endif // GEMINI_H

  

Gemini类中添加了Q_PROPERTY()宏，用来在QObject派生类中声明属性，这个属性如同类的数据成员一样，但它又有一些额外的特性可通过Qt元对象系统来访问。

下面是Q_PROPERTY()宏的原型：

[cpp] view plain copy

 

Q_PROPERTY()(type name  
  (READ getFunction [WRITE setFunction] |  
             MEMBER memberName [(READ getFunction | WRITE setFunction)])  
            [RESET resetFunction]  
            [NOTIFY notifySignal]  
            [REVISION int]  
            [DESIGNABLE bool]  
            [SCRIPTABLE bool]  
            [STORED bool]  
            [USER bool]  
            [CONSTANT]  
            [FINAL])

 

属性的type、name是必需的，其它是可选项，常用的有READ、WRITE、NOTIFY。属性的type可以是QVariant支持的任何类型，也可以是自定义类型，包括自定义类、列表类型、组属性等。另外，属性的READ、WRITE、RESET是可以被继承的，也可以是虚函数，这些特性并不常用。

READ：读取属性值，如果没有设置MEMBER的话，它是必需的。一般情况下，函数是个const函数，返回值类型必须是属性本身的类型或这个类型的const引用，没有参数。

WRITE：设置属性值，可选项。函数必须返回void，有且仅有一个参数，参数类型必须是属性本身的类型或这个类型的指针或引用。

NOTIFY：与属性关联的可选信号。这个信号必须在类中声明过，当属性值改变时，就可触发这个信号，可以没有参数，有参数的话只能是一个类型同属性本身类型的参数，用来记录属性改变后的值。

Q_PROPERTY()的详细用法可参考如下网址：

http://doc.qt.io/qt-5/properties.html#qt-s-property-system

（2）修改main.qml

[sql] view plain copy

 

// main.qml  
import QtQuick 2.2  
import QtQuick.Window 2.1  
import Union.Lotto.Gemini 1.0  
Window {  
    visible: true  
    width: 360; height: 360  
    title: "Union Lotto Game"  
    color: "white"  
    MouseArea {  
        anchors.fill: parent  
        onClicked: {  
            gemini.begin()  
            gemini.stop()  
            gemini.ballNumber = 10  
        }  
    }  
    Gemini {  
        id: gemini  
        onBegin: doSomething(Gemini.BALL_COLOR_RED)  
        onBallNumberChanged: console.log("new ball number is", ballNumber) // 10  
        Component.onCompleted: console.log("default ball number is", ballNumber) // 0  
    }  
}

Gemini类中的ballNumber属性可以在QML中访问、修改，访问时调用了ballNumber()函数，修改时调用了setBallNumber()函数，同时还发送了一个信号来自动更新这个属性值。

4、注册C++类为QML类型

QObject派生类可以注册到Qt元对象系统，使得该类在QML中同其它内建类型一样，可以作为一个数据类型来使用。QML引擎允许注册可实例化的类型，也可以是不可实例化的类型，常见的注册函数有：

[cpp] view plain copy

 

qmlRegisterInterface()  
qmlRegisterRevision()  
qmlRegisterSingletonType()  
qmlRegisterType()  
qmlRegisterTypeNotAvailable()  
qmlRegisterUncreatableType()

这些注册函数各有其用，可根据实际需要选择，使用时需要包含<QtQml>。常用的为qmlRegisterType()，它有三个重载函数，这里只介绍其一：

[cpp] view plain copy

 

template<typename T>  
  int qmlRegisterType(const char *uri,  
int versionMajor,  
int versionMinor,   
       const char *qmlName);

这个模板函数注册C++类到Qt元对象系统中，uri是需要导入到QML中的库名，versionMajor和versionMinor是其版本数字，qmlName是在QML中可以使用的类型名。例如上面例子main.cpp中的代码：

[cpp] view plain copy

 

  1. qmlRegisterType<Gemini>("Union.Lotto.Gemini", 1, 0, "Gemini");  

main.cpp中将Gemini类注册为在QML中可以使用的Gemini类型，主版本为1，次版本为0，库的名字是Union.Lotto.Gemini。main.qml中导入了这个库，使用Gemini构造了一个对象，id为gemini，这样就可以借助id来访问C++了。

注册动作必须在QML上下文创建之前，否则无效。

另外：QQuickView为QtQuickUI提供了一个窗口，可以方便地加载QML文件并显示其界面。QApplication派生自QGuiApplication，而QGuiApplication又派生自QCoreApplication，这三个类是常见的管理Qt应用程序的类。QQmlApplicationEngine可以方便地从一个单一的QML文件中加载应用程序，它派生自QQmlEngine，QQmlEngine则提供了加载QML组件的环境，可以与QQmlComponent、QQmlContext等一起使用。

5、QML上下文属性设置

在C++应用程序加载QML对象时，我们可以直接嵌入一些C++数据来给QML使用，这里需要用到QQmlContext::setContextProperty()，即设置QML上下问属性，它可以是一个简单的类型，也可以是任何我们自定义的类对象。

（1）修改main.cpp

[cpp] view plain copy

 

// main.cpp  
#include <QGuiApplication>  
#include <QQuickView>  
#include <QQmlContext>  
#include <Gemini.h>  
int main(int argc, char *argv[])  
{  
    QGuiApplication app(argc, argv);  
    QQuickView view;  
    Gemini gemini;  
    view.rootContext()->setContextProperty("gemini", &gemini);  
    view.setSource(QUrl(QStringLiteral("qrc:///main.qml")));  
    view.show();  
    return app.exec();  
}

彻底修改一下main.cpp吧，这里使用了QQuickView，注意头文件的变化，Gemini类先实例化为gemini对象，然后注册为QML上下文属性。

（2）修改main.qml

[plain] view plain copy

// main.qml  
import QtQuick 2.2  
Item {  
    width: 360; height: 360  
    MouseArea {  
        anchors.fill: parent  
        onClicked: {  
            gemini.begin()  
            gemini.stop()  
        }  
    }  
    Connections {  
        target: gemini  
        onBegin:console.log("aaaa")  
    }  
}

既然main.cpp修改了那么多东西，main.qml也要做相应的修改，在main.qml中不能使用Gemini类型来实例化了，也不能调用doSomething()槽函数了，因为doSomething()函数中的枚举类型在QML中是访问不到的，正确的用法是通过QML上下文属性“gemini”来访问C++，可以访问信号begin()和成员函数stop()，此时的信号处理器就需要用Connections来处理了，如上面例子中所示。

6、C++访问QML

同样，在C++中也可以访问QML中的属性、函数和信号。

在C++中加载QML文件可以用QQmlComponent或QQuickView，然后就可以在C++中访问QML对象了。QQuickView提供了一个显示用户界面的窗口，而QQmlComponent没有。

QQuickView::rootObject()返回了组件实例，是一个有用的函数。前面的例子中已经使用过QQuickView了，下面的例子介绍QQmlComponent的用法。

使用QQmlComponent——

修改main.cpp

[cpp] view plain copy

// main.cpp  
#include <QGuiApplication>  
#include <QtQml>  
#include <Gemini.h>  
int main(int argc, char *argv[])  
{  
    QGuiApplication app(argc, argv);  
    qmlRegisterType<Gemini>("Union.Lotto.Gemini", 1, 0, "Gemini");  
    QQmlEngine engine;  
    // set qml context property  
    // Gemini aGemini;  
    // engine.rootContext()->setContextProperty("aGemini", &aGemini);  
    QQmlComponent component(&engine, QUrl(QStringLiteral("qrc:///main.qml")));  
    component.create();  
    return app.exec();  
}

 

例子中注释的部分是设置QML上下文属性的方法。

在C++中访问QML中的属性——

在C++中加载了QML文件并进行组件实例化后，就可以在C++中访问、修改这个实例的属性值了，可以是QML内建属性，也可以是自定义属性。

（1）修改main.qml

[plain] view plain copy

// main.qml  
import QtQuick 2.2  
import QtQuick.Window 2.1  
import Union.Lotto.Gemini 1.0  
Window {  
    visible: true  
    width: 360; height: 360  
    title: "Union Lotto Game"  
    color: "white"  
    Rectangle {  
        objectName: "rect"  
        anchors.fill: parent  
        color: "yellow"  
    }  
    MouseArea {  
        anchors.fill: parent  
        onClicked: {  
            gemini.begin()  
            gemini.stop()  
            gemini.ballNumber = 10  
        }  
    }  
    Gemini {  
        id: gemini  
        onBegin: doSomething(Gemini.BALL_COLOR_RED)  
        onBallNumberChanged: console.log("new ball number is", ballNumber) // 10  
        Component.onCompleted: console.log("default ball number is", ballNumber) // 0  
    }  
}

在main.qml中添加了一个Rectangle，设置objectName属性值为“rect”，这个值是为了在C++中能够找到这个Rectangle。

（2）修改main.cpp

[cpp] view plain copy

// main.cpp  
#include <QGuiApplication>  
#include <QtQml>  
#include <Gemini.h>  
int main(int argc, char *argv[])  
{  
    QGuiApplication app(argc, argv);  
    qmlRegisterType<Gemini>("Union.Lotto.Gemini", 1, 0, "Gemini");  
    QQmlEngine engine;  
    // set qml context property  
    // Gemini aGemini;  
    // engine.rootContext()->setContextProperty("aGemini", &aGemini);  
    QQmlComponent component(&engine, QUrl(QStringLiteral("qrc:///main.qml")));  
    QObject *object = component.create();  
    qDebug() << "width value is" << object->property("width").toInt();  
    object->setProperty("width", 500);  
    qDebug() << "height value is" << QQmlProperty::read(object, "height").toInt();  
    QQmlProperty::write(object, "height", 500);  
    QObject *rect = object->findChild<QObject*>("rect");  
    if(rect) {  
        rect->setProperty("color", "black");  
    }  
    return app.exec();  
}

首先，使用了QObject::property()/setProperty()来读取、修改width属性值。

接着，使用了QQmlProperty::read()/write()来读取、修改height属性值。

另外，如果某个对象的类型是QQuickItem，例如QQuickView::rootObject()的返回值，这时就可以使用QQuickItem::width/setWidth()来访问、修改width属性值了。

有时候，QML组件是一个复杂的树型结构，包含兄弟组件和孩子组件，我们可以使用QObject::findchild()/findchildren()来查找，如上面例子所示。

在C++中访问QML中的函数与信号——

在C++中，使用QMetaObject::invokeMethod()可以调用QML中的函数，从QML传递过来的函数参数和返回值会被转换为C++中的QVariant类型，成功返回true，参数不正确或被调用函数名错误返回false，invokeMethod()共有四个重载函数，用法相似。必须使用Q_ARG()宏来声明函数参数，用Q_RETURN_ARG()宏来声明函数返回值，其原型如下：

[cpp] view plain copy

QGenericArgument           Q_ARG(Type, const Type & value)  
QGenericReturnArgument     Q_RETURN_ARG(Type, Type & value)

使用QObject::connect()可以连接QML中的信号，connect()共有四个重载函数，它们都是静态函数。必须使用SIGNAL()宏来声明信号，SLOT()宏声明槽函数。

使用QObject::disconnect()可以解除信号与槽函数的连接。

（1）修改main.qml

[plain] view plain copy

import QtQuick 2.2  
import QtQuick.Window 2.1  
import Union.Lotto.Gemini 1.0  
Window {  
    visible: true  
    width: 360; height: 360  
    title: "Union Lotto Game"  
    color: "white"  
    signal qmlSignal(string message)  
    onQmlSignal: console.log("qml signal message is", message) // this is a qml signal  
    function qmlFunction(parameter) {  
        console.log("qml function parameter is", parameter) // Hello from C++  
        return "function from qml"  
    }  
    Rectangle {  
        objectName: "rect"  
        anchors.fill: parent  
        color: "yellow"  
    }  
    MouseArea {  
        anchors.fill: parent  
        onClicked: {  
            gemini.begin()  
            gemini.stop()  
            gemini.ballNumber = 10  
            qmlSignal("this is a qml signal")  
        }  
    }  
    Gemini {  
        id: gemini  
        onBegin: doSomething(Gemini.BALL_COLOR_RED)  
        onBallNumberChanged: console.log("new ball number is", ballNumber) // 10  
        Component.onCompleted: console.log("default ball number is", ballNumber) // 0  
    }  
}


 

main.qml中添加了qmlSignal()信号和qmlFunction()函数，信号在QML中发送，函数在C++中调用。

（2）修改Gemini.h

[cpp] view plain copy

#ifndef GEMINI_H  
#define GEMINI_H  
// Gemini.h  
#include <QObject>  
#include <QDebug>  
class Gemini : public QObject  
{  
    Q_OBJECT  
    Q_ENUMS(BALL_COLOR)  
    Q_PROPERTY(unsigned int ballNumber READ ballNumber WRITE setBallNumber NOTIFY ballNumberChanged)  
public:  
    Gemini() : m_ballColor(BALL_COLOR_YELLOW), m_ballNumber(0) {  
        qDebug() << "Gemini::Gemini() called";  
    }  
    enum BALL_COLOR {  
        BALL_COLOR_YELLOW,  
        BALL_COLOR_RED,  
        BALL_COLOR_BLUE,  
        BALL_COLOR_ALL  
    };  
    unsigned int ballNumber() const {  
        return m_ballNumber;  
    }  
    void setBallNumber(const unsigned int &ballNumber) {  
        if(ballNumber != m_ballNumber) {  
            m_ballNumber = ballNumber;  
            emit ballNumberChanged();  
        }  
    }  
    Q_INVOKABLE void stop() {  
        qDebug() << "Gemini::stop() called";  
    }  
signals:  
    void begin();  
    void ballNumberChanged();  
public slots:  
    void doSomething(BALL_COLOR ballColor) {  
        qDebug() << "Gemini::doSomething() called with" << ballColor;  
        if(ballColor != m_ballColor) {  
            m_ballColor = ballColor;  
            qDebug() << "ball color changed";  
        }  
    }  
    void cppSlot(const QString &message) {  
        qDebug() << "Called the C++ slot with message:" << message; // this is a qml signal  
    }  
private:  
    BALL_COLOR m_ballColor;  
    unsigned int m_ballNumber;  
};  
#endif // GEMINI_H

Gemini类中添加了cppSlot()槽函数，将要在main.cpp中与QML的信号connect。

（3）修改main.cpp

[cpp] view plain copy

    #include <QGuiApplication>  
    #include <QtQml>  
    #include <Gemini.h>  
    int main(int argc, char *argv[])  
    {  
        QGuiApplication app(argc, argv);  
        qmlRegisterType<Gemini>("Union.Lotto.Gemini", 1, 0, "Gemini");  
        QQmlEngine engine;  
        // set qml context property  
        // Gemini aGemini;  
        // engine.rootContext()->setContextProperty("aGemini", &aGemini);  
        QQmlComponent component(&engine, QUrl(QStringLiteral("qrc:///main.qml")));  
        QObject *object = component.create();  
        qDebug() << "width value is" << object->property("width").toInt();  
        object->setProperty("width", 500);  
        qDebug() << "height value is" << QQmlProperty::read(object, "height").toInt();  
        QQmlProperty::write(object, "height", 500);  
        QObject *rect = object->findChild<QObject*>("rect");  
        if(rect) {  
            rect->setProperty("color", "black");  
        }  
        QVariant returnedValue;  
        QVariant message = "Hello from C++";  
        QMetaObject::invokeMethod(object, "qmlFunction",  
                                  Q_RETURN_ARG(QVariant, returnedValue),  
                                  Q_ARG(QVariant, message));  
        qDebug() << "returnedValue is" << returnedValue.toString(); // function from qml  
        Gemini test;  
        QObject::connect(object, SIGNAL(qmlSignal(QString)),  
                         &test, SLOT(cppSlot(QString)));  
        return app.exec();  
    }

在main.cpp中添加了QMeta::invokeMethod()和QObject::connect()来分别访问QML中函数和信号。

7、总结

本文主要介绍了QML与C++混合编程常用的方法与技巧，在使用过程中有几点值得注意：

         自定义类一定要派生自QObject类或其子类。

         必须使用Q_OBJECT宏。

         注册自定义类到Qt元对象系统或设置自定义类对象实例为QML上下文属性是必须的。

         两者交互进行数据传递时，要符合QML与C++间数据类型的转换规则。

 

 

 

 

A 壹零贰肆
关注
  • 4
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
QT qml的入门使用
道亦无名
08-03 871
结构如下： main.cpp代码： #include <QGuiApplication> #include <QQmlApplicationEngine> int main(int argc, char *argv[]) { QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling); QGuiApplication app(argc, argv); QQmlApplicationEngine
Qt Quick 之 QML 与 C++ 混合编程详解
宁静致远的博客
09-11 1216
但它不是万能的，也有很多局限性，原来 Qt 的一些技术，比如低阶的网络编程如 QTcpSocket ，多线程，又如 XML 文档处理类库 QXmlStreamReader / QXmlStreamWriter 等等，在 QML 中要么不可用，要么用起来不方便，所以呢，很多时候我们是会基于这样的原则来混合使用 QML 和 C++： QML 构建界面， C++ 实现非界面的业务逻辑和复杂运算。一旦你在 C++ 中注册好了 QML 类型，就可以在 QML 文档中引入你注册的包，然后使用注册的类型。
QML 与C++交互详解
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
03-16 3189
1.Qt 的元对象系统Qt 的元对象系统（Meta-Object System）提供了对象之间通信的信号与槽机制、运行时类型信息和动态属性系统。在一个类的 private 部分声明 Q_OBJECT宏，使得类可以使用元对象的特性，如动态属性、信号与槽。自定义一个C++类 MyObject 对象，有两个成员变量m_value和m_str，分别对应一个set和一个get方法，还有一个信号，还是使用上面的类，首先在C++中增加一个槽函数，打印一些信息。还是使用上面的类，首先在C++中增加一个信号。
【QT教程】QML与C++的交互
最新发布
QT界面开发界面美化
04-04 1418
在C++中，我们实现了一个名为setValue的槽，用于改变属性的值，并发出valueChanged信号，以通知QML属性已经发生变化。在QT技术栈中，QML与C++的交互是构建现代应用程序的常见做法，特别是在涉及到用户界面和后端逻辑的时候。庆幸的是，我们可以利用C++强大的测试框架，如Google Test，结合Qt框架提供的功能来实现QML的单元测试。记住，QML和C++之间的交互是通过信号和槽来实现的，确保在QML中正确地连接这些信号和槽，以便能够响应用户的操作并更新界面。
Qml与C++信号槽交互
youthshadows的博客
10-05 493
步骤和widgets项目创建c++类一样，如果使用场景可以确定为全局唯一，我们可以直接创建单例。#endifif (!//注册在engine.load(url)之前注册，尤其是注册静态实例时，需要确保qml加载时该静态对象已经实例化。Window {width: 640MyObject{id: myobj//当value以 = 号赋值的方式，将变成静止的值QT的特色之一就是信号槽了，使用信号槽可以使编程变得极为灵活。
Qt QML 与 C++ 交互 信号与槽 属性 注册等初学者手册
你学习了吗？咋办，先想法子忽悠成“砖家”呗
08-02 2438
前言   QML 是一套 QT 开发前端显示的软件，其最大特色就是基于 Qt 的宏系统实现了与 C++ 及 Javascript 交互和连接，本篇主要讲解 QML 与 C++ 的交互（ QML 调用 C++），至于 C++ 调用 QML 部分相对比较简单查看官方文档即可   很多 C++ 与 QML 以及 Javascript 的变量，宏系统会自动进行切换 目录结构 官方文档 Official ...
QML与C++混合编程
aming090的博客
10-29 1489
QT开发（六十九）——QML与C++混合编程 一、QML与C++混合编程简介     QML与C++混合编程就是使用QML高效便捷地构建UI，而C++则用来实现业务逻辑和复杂算法。 二、QML访问C++     Qt集成了QML引擎和Qt元对象系统，使得QML很容易从C++中得到扩展，在一定的条件下，QML就可以访问QObject派生类的成员，例如信号、槽函数、枚举类型、属性、成员函数等。...
QT QML信号与信号槽详解
06-20
详细介绍QT中后台代码C++与前端QML之间，通过信号与信号槽进行通信的机制。
QtQuick组件与对象动态创建详解（一）
03-03
Component是由Qt框架或开发者封装好的、只暴露了必要接口的QML类型，可以重复利用。一个QML组件就像一个黑盒子，它通过属性、信号、函数和外部世界...《QtQuick事件处理之信号与槽》一文中使用到Component的示例QML代
Qt5.8中QML教程并结合实际工程项目详解
01-27
这篇博客会介绍一下Qt中使用QML来设计GUI界面，以及QML与C++交互的方式。QML是Qt自定义的一种GUI描述文件，其文档结构有点类似NodeJS或者TypeScript，跟Android编程中的Activity的设计也很类似，在客户端GUI编程的...
如何将带有信号与槽的C++代码暴露给QML
wanywhn的博客
12-05 818
使用QML进行应用程序开发简单而强大。但是Qt C ++可以提高性能，提供许多功能并且不易出错。这篇文章向您展示了如何创建利用这两种语言的应用程序。 文章目录如何在C ++和QML之间进行通信QML中编码的优点何时使用C ++代替如何从QML访问C ++对象在项目中创建C ++类使用QML实现带有信号和插槽的C ++类将对象公开为QML作为Context属性添加具有完整QML支持的类属性如何将C...
Qt实例分析——QML调用C++方法, C++调用QML（
08-28
QML调用C++方法, C++调用QML，C++发送信号QML接收
C++传数据给Qml
上官宏竹的专栏
07-27 2313
的话，QVariant里可以放任何你想要的数据结构，一般都是自定义的居多。如果不是自定义的数据，可以直接使用QT的定义类型。那么在QML中，QMAP被当做了一个JavaScript的字典对待。这个信号，并传入自定义的数据结构。如果想给QML传入键值对，可以使用QMap类型，依然的可以使用。以上两种类型，都可以传QList，比如。C++通过发送信号，附带参数给QML。C++类通过返回类型给QML。QVariantList是。上述是qml的槽函数，连接了。，给它传入自定义的数据结构。..............
从 C++ 定义 QML 类型
友善啊，朋友的博客
11-30 2742
使用 C++ 代码扩展 QML 时，可以使用 QML 类型系统注册 C++ 类，使 C++类能够用作 QML 代码中的数据类型。虽然任何 QObject 派生类的属性、方法和信号都可以从 QML 访问，但只有注册的的类才能用作 QML 的数据类型。 一、使用 QML 类型系统注册 C++ 类型 QObject 派生类可以在 QML 类型系统中注册。 QML引擎允许注册可实例化类型和不可实例化类型： 注册可实例化类型使 C++ 类可以用作 QML 对象类型的定义，从而允许在 QML 代码的对象声明中使
qt qml c++ 画动态折线图
热门推荐
03-26 1万+
qt版本5.2 QtQuick2.0  显示：可横向拖动  源码地址 http://download.csdn.net/detail/zzjzmdx/7113719 源码包包含：main.cpp app.qml linechart.cpp linechart.h  main.c int main(int argc, char *argv[]) { Q
QT QComboBox中的currentIndexChanged信号重载编译报错（...无法将参数2从“overloaded-funtion“转化为“const char*“）
weixin_44901043的博客
02-18 1392
报错内容： 问题描述： 这是由于QComboBox中的currentIndexChanged信号重载导致： 解决方式： QT5新版的信号槽语法，进行强制类型转换： connect(ui->comboBox,static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),this,&Widget::onCurrentIndexChanged); connect(ui->comboBox,
Qt信号重载
焕小谢的博客
10-09 2044
信号重载后，按照原来的写法写的代码（错误的写法）： QT信号重载后，我们的槽函数如何接收这个信号？ 下面的案例就是点击“发出信号”这个按钮，将发出信号，然后当前窗体就会接收这个信号并进行相对应的打印操作。 MainWindow.h #ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QMainWindow> namespace U...
【QML 与 C++ 之间的通讯机制 】深入解析 Qt 中的 Q_INVOKABLE：桥接 QML 和 C++
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-14 1227
`Q_INVOKABLE` 宏的设计初衷，是为了让 QML 能够访问 C++ 类中的成员函数。在技术层面上，这看似是一项小改动，但在应用层面上，它极大地丰富了 QML 的表现力。通过这一宏，复杂的数据处理和业务逻辑可以在 C++ 中实现，而 QML 则专注于轻量级的用户界面表述。这种分工，不仅使代码更加清晰，也提高了整个应用的性能和可维护性。
QML与C++混合编程（三）在C++中定义QML类型
鬼马行天的博客
07-19 1078
在C++中定义QML类型
qml与c++混合编程
07-15
总结来说，QML与C++的混合编程方式可以在开发过程中充分利用两者的优势，快速构建用户界面并处理复杂的业务逻辑。这种结合使得开发人员能够更有效地开发出高性能、用户友好的应用程序。 ### 回答3： qml与C混合...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值