Capítulo 1 Mecanismos comunes de comunicación de datos de QT

En Qt, hay muchas formas de lograr la comunicación de datos, a continuación se enumeran algunos métodos comúnmente utilizados:

Mecanismo de señal y ranura: El mecanismo de señal y ranura de Qt es un mecanismo basado en eventos para la comunicación entre objetos. La comunicación de datos entre objetos se puede realizar definiendo una señal en el objeto emisor, definiendo una función de ranura en el objeto receptor y usando connectuna función para conectar la señal y la función de ranura. Las señales pueden tomar parámetros para pasar datos a funciones de ranura.
Mecanismo de eventos: los objetos en Qt pueden realizar la comunicación de datos definiendo y activando eventos personalizados. QEventCree y envíe eventos en el objeto emisor heredando la clase y reescribiendo las funciones relacionadas, y reescribiendo la función de procesamiento de eventos en el objeto receptor para recibir y procesar eventos.
Variables/datos compartidos: el uso de variables o datos compartidos es una manera sencilla de comunicarse. Los datos se pueden compartir entre varios objetos y la coherencia de los datos se puede garantizar en un entorno de subprocesos múltiples mediante la protección síncrona de lectura y escritura de datos. Qt proporciona primitivas de sincronización como el bloqueo de exclusión mutua ( QMutex) y el bloqueo de lectura y escritura ( ), que se pueden utilizar para realizar un acceso síncrono a los datos.QReadWriteLock
Conectores locales: Qt proporciona QLocalSocketclases QLocalServerpara la comunicación local entre procesos en la misma máquina. El intercambio de datos entre procesos se puede lograr utilizando sockets locales. Un proceso se puede usar como servidor QLocalServerpara escuchar solicitudes de conexión y el otro proceso se puede usar como cliente para QLocalSocketconectarse al servidor y enviar/recibir datos.
Enchufe de red: Qt QTcpSockety QUdpSocketclase proporcionan la función de comunicarse con el proceso en la computadora remota, que puede realizar la comunicación de datos de red. QTcpSocketSe puede utilizar para establecer una conexión TCP, pero QUdpSocketes adecuado para la comunicación de datos mediante el protocolo UDP.
Qt Remote Objects: Qt Remote Objects (Objetos remotos Qt) es un marco para la comunicación de datos distribuidos. Permite el intercambio de datos y señales entre aplicaciones Qt en diferentes procesos, dispositivos o redes. Con Qt Remote Objects, puede definir y usar objetos distribuidos y comunicar datos a través de llamadas remotas y mecanismos de ranura de señal.

Los anteriores son solo algunos de los métodos de comunicación de datos Qt más utilizados. Qt también proporciona otras herramientas y mecanismos de comunicación, como QtDBus para la interacción de datos D-Bus, QtWebSockets para la comunicación WebSocket, etc. Puede elegir el método de comunicación adecuado según sus necesidades específicas. La elección específica depende de los requisitos de su aplicación y las características de la comunicación de datos.

Capítulo 2 Código de muestra

Aquí hay un código de muestra simple que demuestra los diferentes mecanismos de comunicación de datos en Qt:

1. Ejemplo de mecanismo de señal y ranura:

// Sender.h
#ifndef SENDER_H
#define SENDER_H

#include <QObject>

class Sender : public QObject
{
    Q_OBJECT
public:
    explicit Sender(QObject *parent = nullptr);

signals:
    void dataReady(int data);
};

// Receiver.h
#ifndef RECEIVER_H
#define RECEIVER_H

#include <QObject>

class Receiver : public QObject
{
    Q_OBJECT
public:
    explicit Receiver(QObject *parent = nullptr);

public slots:
    void processData(int data);
};

// main.cpp
#include <QCoreApplication>
#include "Sender.h"
#include "Receiver.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Sender sender;
    Receiver receiver;

    // 将Sender的dataReady信号与Receiver的processData槽函数连接
    QObject::connect(&sender, &Sender::dataReady, &receiver, &Receiver::processData);
    
    // 发送数据
    sender.emit dataReady(123);

    return a.exec();
}

2. Ejemplo de variable/datos compartidos:

// Worker.h
#ifndef WORKER_H
#define WORKER_H

#include <QObject>
#include <QMutex>

class Worker : public QObject
{
    Q_OBJECT
public:
    explicit Worker(QObject *parent = nullptr);

public slots:
    void writeData(int data);

signals:
    void readData(int data);

private:
    QMutex mutex;
    int sharedData;
};

// main.cpp
#include <QCoreApplication>
#include "Worker.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Worker worker;
    
    // 将共享数据的读写操作放在互斥锁中进行保护
    worker.writeData(123);
    
    QMutexLocker locker(&worker.mutex); // 自动加锁
    int data = worker.sharedData;
    locker.unlock(); // 解锁
    
    worker.emit readData(data);

    return a.exec();
}

3. Ejemplo de toma local:

// Server.h
#ifndef SERVER_H
#define SERVER_H

#include <QObject>
#include <QLocalServer>
#include <QLocalSocket>

class Server : public QObject
{
    Q_OBJECT
public:
    explicit Server(QObject *parent = nullptr);

signals:

public slots:
    void newConnection();

private:
    QLocalServer *localServer;
    QLocalSocket *clientSocket;
};

// Client.h
#ifndef CLIENT_H
#define CLIENT_H

#include <QObject>
#include <QLocalSocket>

class Client : public QObject
{
    Q_OBJECT
public:
    explicit Client(QObject *parent = nullptr);

public slots:
    void connected();
    void readyRead();

private:
    QLocalSocket *localSocket;
};

// main.cpp
#include <QCoreApplication>
#include "Server.h"
#include "Client.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Server server;
    Client client;
    
    // 服务器监听本地连接请求
    QObject::connect(server.localServer, &QLocalServer::newConnection, &server, &Server::newConnection);
    
    // 客户端连接到服务器，并发送数据
    client.localSocket->connectToServer("myLocalServer");
    QObject::connect(client.localSocket, &QLocalSocket::connected, &client, &Client::connected);
    QObject::connect(client.localSocket, &QLocalSocket::readyRead, &client, &Client::readyRead);
    
    return a.exec();
}

Estos ejemplos simplemente demuestran los diferentes mecanismos de comunicación en Qt. Puede modificar y ampliar según las necesidades y los escenarios específicos. Tenga en cuenta que es posible que los errores u otras condiciones anormales no se manejen en estos ejemplos, y se debe realizar el manejo de errores y el manejo de excepciones apropiados según sea necesario en el uso real.

[Serie de Programación QT-24]: Mecanismo de Subprocesos Múltiples - Mecanismo de Comunicación de Datos QT

Capítulo 1 Mecanismos comunes de comunicación de datos de QT

Capítulo 2 Código de muestra

1. Ejemplo de mecanismo de señal y ranura:

2. Ejemplo de variable/datos compartidos:

3. Ejemplo de toma local:

Supongo que te gusta