QLocalSocket 应用举例

QLocalSocket本地套接字应用举例
原创 已于 2025-07-16 15:31:20 修改 · 668 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ubuntu

于 2025-06-27 19:31:49 首次发布

1.概要

1.目的：本地套接字简单应用举例。

2.基本步骤：

  • 1.服务开启，开始监听
  • 2.客户端开始，链接服务端，发生数据
  • 3.服务端收到数据，写入屏幕，并回复给客户端数据
  • 4.客户端收到数据，屏幕输出收到的数据

3.实验方法：qtcreator打开两个应用，一个运行服务端，一个运行客户端。

4.实验结果：

服务端：

Server listening on: "my_local_socket"
Received: "Hello from client!"

客户端：

Server response: "Hello from server!"

5.记忆要点

QLocalServer 本地链接服务
newConnection 有新的链接信号
listen 监听服务名称，系统唯一标识符
nextPendingConnection 获取当前链接对象
readyRead 读取链接中的数据
readAll 读取全部数据
write 写入数据给链接端
connectToServer 链接服务端，前面的唯一名称标识
waitForConnected 等待链接是否超时
waitForReadyRead  等待接收数据 

2.内容

QLocalSocket 是 Qt 框架中用于本地进程间通信（IPC）的类，它通过 Unix 域套接字（Unix-like 系统）或命名管道（Windows）实现同一台机器上的进程间数据传输。以下是典型应用场景和示例代码：

典型应用场景

  1. 本地服务通信：客户端-服务器模型，如后台服务与 GUI 界面交互。
  2. 进程间数据传递：替代共享内存或管道，简化复杂数据结构的传输。
  3. 服务发现：通过固定套接字名称标识服务（如 my_service）。

示例 1：简单客户端-服务器通信

服务器端代码（使用 QLocalServer）

#include <QCoreApplication>
#include <QLocalServer>
#include <QLocalSocket>
#include <QDebug>

class LocalServer : public QLocalServer {
    Q_OBJECT
public:
    LocalServer(QObject *parent = nullptr) : QLocalServer(parent) {
        connect(this, &QLocalServer::newConnection, this, &LocalServer::handleNewConnection);
    }

    void startServer(const QString &serverName) {
        if (!listen(serverName)) {
            qWarning() << "Server failed to start:" << errorString();
            return;
        }
        qDebug() << "Server listening on:" << serverName;
    }

private slots:
    void handleNewConnection() {
        QLocalSocket *clientSocket = nextPendingConnection();
        connect(clientSocket, &QLocalSocket::readyRead, [clientSocket]() {
            QByteArray data = clientSocket->readAll();
            qDebug() << "Received:" << data;
            clientSocket->write("Hello from server!");
        });
        connect(clientSocket, &QLocalSocket::disconnected, clientSocket, &QLocalSocket::deleteLater);
    }
};

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);
    LocalServer server;
    server.startServer("my_local_socket");
    return a.exec();
}
客户端代码（使用 QLocalSocket）
#include <QCoreApplication>
#include <QLocalSocket>
#include <QDebug>

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

    // 连接服务器
    socket.connectToServer("my_local_socket");
    if (!socket.waitForConnected(3000)) {
        qWarning() << "Connection failed:" << socket.errorString();
        return 1;
    }

    // 发送数据
    socket.write("Hello from client!");
    if (!socket.waitForBytesWritten()) {
        qWarning() << "Write failed:" << socket.errorString();
        return 1;
    }

    // 接收响应
    if (socket.waitForReadyRead(3000)) {
        qDebug() << "Server response:" << socket.readAll();
    } else {
        qWarning() << "No response from server.";
    }

    socket.disconnectFromServer();
    return a.exec();
}

运行结果

服务端：

Server listening on: "my_local_socket"
Received: "Hello from client!"

客户端：

Server response: "Hello from server!"

代码分析 

关键步骤说明

  1. 服务器端：
    • 创建 QLocalServer 实例并监听指定名称（如 "my_local_socket"）。
    • 通过 newConnection 信号处理新客户端连接。
    • 使用 nextPendingConnection() 获取客户端套接字，并监听其 readyRead 信号读取数据。
  2. 客户端：
    • 创建 QLocalSocket 实例并调用 connectToServer()。
    • 通过 waitForConnected() 确保连接成功。
    • 使用 write() 发送数据，readAll() 接收响应。

注意事项

  1. 跨平台行为：
    • Unix-like 系统使用 Unix 域套接字（文件路径如 /tmp/my_socket）。
    • Windows 使用命名管道（名称如 \\.\pipe\my_socket）。
    • Qt 自动处理底层差异，开发者无需关心。
  2. 错误处理：
    • 检查 waitForConnected() 和 waitForReadyRead() 的返回值。
    • 处理 errorString() 获取详细错误信息。
  3. 并发连接：
    • 服务器默认支持多客户端连接（通过 nextPendingConnection() 循环处理）。

应用扩展

  • 数据序列化：使用 QDataStream 传输复杂数据结构（如结构体、类对象）。
  • 超时控制：通过 QTimer 实现连接/读写超时机制。
  • 服务唯一性：在启动服务器前检查套接字是否存在，避免端口冲突。

通过 QLocalSocket，开发者可以高效实现本地进程间通信，适用于需要低延迟、高安全性的场景。

3.关联链接

4.关联知识

1.QLocalServer

QLocalServer 是 Qt 框架中用于创建本地套接字服务器的类，通常与 QLocalSocket 配合使用，实现同一台机器上的进程间通信（IPC）。以下是其核心用法和示例：

核心功能

  1. 监听本地套接字：通过名称（如 "my_service"）标识服务，客户端通过该名称连接。
  2. 处理多客户端连接：自动管理多个客户端的并发连接。
  3. 跨平台支持：底层实现自动适配 Unix 域套接字（Unix-like）或命名管道（Windows）。

基本用法示例

1. 创建并启动服务器

#include <QLocalServer>
#include <QLocalSocket>
#include <QDebug>

class MyServer : public QLocalServer {
    Q_OBJECT
public:
    MyServer(QObject *parent = nullptr) : QLocalServer(parent) {
        // 连接新客户端信号
        connect(this, &QLocalServer::newConnection, this, &MyServer::handleNewClient);
    }

    bool start(const QString &serverName) {
        // 移除可能存在的旧套接字文件（Unix特有）
        QLocalServer::removeServer(serverName);
        
        // 启动监听
        if (!listen(serverName)) {
            qWarning() << "Failed to start server:" << errorString();
            return false;
        }
        qDebug() << "Server started on:" << serverName;
        return true;
    }

private slots:
    void handleNewClient() {
        // 获取新客户端套接字
        QLocalSocket *clientSocket = nextPendingConnection();
        qDebug() << "New client connected from:" << clientSocket->fullServerName();

        // 读取客户端数据
        connect(clientSocket, &QLocalSocket::readyRead, [clientSocket]() {
            QByteArray data = clientSocket->readAll();
            qDebug() << "Received:" << data;
            
            // 回显数据给客户端
            clientSocket->write("Echo: " + data);
        });

        // 客户端断开时清理资源
        connect(clientSocket, &QLocalSocket::disconnected, clientSocket, &QLocalSocket::deleteLater);
    }
};
2. 客户端连接测试

QLocalSocket socket;
socket.connectToServer("my_service");
if (socket.waitForConnected(3000)) {
    socket.write("Hello Server!");
    if (socket.waitForReadyRead(3000)) {
        qDebug() << "Server replied:" << socket.readAll();
    }
    socket.disconnectFromServer();
} else {
    qWarning() << "Connect failed:" << socket.errorString();
}

关键步骤说明

  1. 启动服务器：
    • 调用 listen(serverName) 监听指定名称。
    • 在 Unix 系统中，若需复用套接字文件，需先调用 removeServer(serverName)。
  2. 处理新连接：
    • 通过 newConnection 信号触发槽函数。
    • 使用 nextPendingConnection() 获取客户端套接字对象。
  3. 数据读写：
    • 监听 readyRead 信号读取数据。
    • 使用 write() 发送响应，通过 waitForBytesWritten() 确保数据发送。
  4. 资源清理：
    • 客户端断开时，通过 disconnected 信号自动删除套接字对象。

高级用法

1. 多线程处理客户端

为每个客户端连接创建独立线程，避免主线程阻塞：

void handleNewClient() {
    QLocalSocket *clientSocket = nextPendingConnection();
    QThread *thread = new QThread;
    ClientHandler *handler = new ClientHandler(clientSocket);
    handler->moveToThread(thread);
    
    connect(thread, &QThread::started, handler, &ClientHandler::process);
    connect(handler, &ClientHandler::finished, thread, &QThread::quit);
    connect(thread, &QThread::finished, handler, &ClientHandler::deleteLater);
    connect(thread, &QThread::finished, thread, &QThread::deleteLater);
    
    thread->start();
}
2. 自定义协议

通过 QDataStream 序列化复杂数据：

// 服务器端写入结构化数据
QDataStream out(clientSocket);
out.setVersion(QDataStream::Qt_5_15);
out << quint32(12345) << QString("Hello");

// 客户端读取
QDataStream in(socket);
in.setVersion(QDataStream::Qt_5_15);
quint32 magic;
QString message;
in >> magic >> message;

注意事项

  1. 套接字名称唯一性：
    • 确保服务器名称唯一，避免端口冲突。
    • 在 Unix 中，套接字文件默认位于 /tmp 目录。
  2. 错误处理：
    • 检查 listen() 和 connectToServer() 的返回值。
    • 处理 errorString() 获取详细错误信息（如权限不足、名称被占用）。
  3. 跨平台兼容性：
    • Windows 命名管道名称需以 \\.\pipe\ 开头（Qt 自动处理）。

适用场景

  • 同一台机器上的后台服务与 GUI 通信。
  • 需要高效、安全的本地进程间数据传输。
  • 替代共享内存或 D-Bus 的简单 IPC 需求。

通过 QLocalServer，开发者可以快速构建稳定的本地服务，适用于需要低延迟和高安全性的应用场景。

1.QLocalSocket详细解释 

QLocalSocket 详解（无长代码）

1. 核心概念

QLocalSocket 是 Qt 框架中用于本地进程间通信（IPC）的类，基于操作系统底层的本地套接字机制实现：

  • Unix/Linux：底层使用 AF_UNIX 域套接字（文件系统路径标识，如 /tmp/socket）。
  • Windows：底层使用命名管道（Named Pipes），通过唯一名称标识（如 "MyApp_Socket"）。
  • 跨平台抽象：Qt 封装了平台差异，提供统一 API。
2. 典型工作流程
  • 服务器端：通过 QLocalServer 监听连接请求。
  • 客户端：通过 QLocalSocket 发起连接，建立双向通信通道。
3. 关键方法
  • 连接服务器： 
    socket.connectToServer("ServerName"); // 异步连接，不阻塞
  • 数据读写： 

    socket.write(data); // 发送数据（异步）
QByteArray data = socket.readAll(); // 读取数据（同步或异步）
  • 状态管理： 

    if (socket.state() == QLocalSocket::ConnectedState) {
    // 已连接
}
4. 核心信号
  • 连接状态：
    • connected(): 连接成功时触发。
    • disconnected(): 连接断开时触发。
    • errorOccurred(QLocalSocket::LocalSocketError error): 错误处理（如连接失败）。
  • 数据就绪：
    • readyRead(): 有新数据可读时触发，需在此信号连接的槽函数中调用 read()。
5. 使用场景
  • 同一台机器上的进程间高效通信（如客户端-服务端架构）。
  • 替代共享内存或管道，简化复杂数据传输（支持流式或分组数据）。
  • 与系统服务交互（如模拟网络协议的本地测试）。
6. 注意事项
  • 异步特性：所有操作默认非阻塞，需通过信号槽处理结果。
  • 单连接限制：一个 QLocalSocket 实例一次只能连接一个服务器。
  • 跨平台兼容性：
    • Unix 路径需可写权限（如 /tmp/ 目录）。
    • Windows 命名管道名称需全局唯一（避免冲突）。
  • 错误处理：务必监听 errorOccurred 信号，避免静默失败。
7. 简单流程示例
  1. 服务器启动：
    • 创建 QLocalServer，绑定唯一名称（如 "MyService"）。
    • 监听 newConnection 信号，通过 nextPendingConnection() 获取客户端 QLocalSocket。
  2. 客户端连接：
    • 创建 QLocalSocket，调用 connectToServer("MyService")。
    • 连接成功后，通过 write() 发送数据，监听 readyRead() 接收响应。
8. 对比 QTcpSocket
  • 相同点：API 设计类似（如 write(), read(), 信号机制）。
  • 不同点：
    • QLocalSocket 仅限本地通信，无网络开销。
    • QTcpSocket 支持跨机器通信，需处理网络层细节。

通过 QLocalSocket，开发者可以快速实现高效、跨平台的本地进程通信，适用于需要低延迟或高安全性的本地服务集成场景。

2.QLocalSocket常用接口

QLocalSocket 是 Qt 框架中用于本地进程间通信（IPC）的核心类，其接口设计简洁且功能强大。以下是其常用接口的分类说明及示例：

一、连接管理接口

  1. connectToServer
    尝试连接到指定名称的本地服务器：

    void connectToServer(const QString &name, QIODeviceBase::OpenMode openMode = QIODeviceBase::ReadWrite);
    • 参数：name 为服务器名称，openMode 指定读写模式（默认为读写）。
    • 示例：socket->connectToServer("my_server");

  2. disconnectFromServer
    断开与当前服务器的连接，并等待所有数据写入完成后再关闭：

    void disconnectFromServer();

  3. abort
    立即终止连接，并清空写缓冲区中未处理的数据，不等待数据写入完成：

    void abort();

  4. waitForConnected
    阻塞当前线程，直到连接建立或超时（默认超时 30 秒）：

    bool waitForConnected(int msecs = 30000);

二、数据传输接口

  1. write
    将数据写入套接字，发送到服务器：

    qint64 write(const QByteArray &data);
    • 示例：socket->write("Hello, Server!");

  2. read / readAll
    从套接字中读取数据：

    QByteArray read(qint64 maxSize); // 读取最多 maxSize 字节
QByteArray readAll(); // 读取所有可用数据

  3. flush
    将写缓冲区中的数据尽可能多地写入套接字，返回是否成功写入至少一个字节：

    bool flush();

三、状态查询接口

  1. state
    返回套接字的当前状态：

    QLocalSocket::LocalSocketState state() const;
    • 状态枚举：UnconnectedState, ConnectingState, ConnectedState, ClosingState。

  2. isValid
    检查套接字是否有效（即是否已成功打开）：

    bool isValid() const;

  3. bytesAvailable / bytesToWrite
    查询数据缓冲状态：

    qint64 bytesAvailable() const; // 可立即读取的字节数
qint64 bytesToWrite() const; // 写缓冲区中尚未写入的字节数

四、错误处理接口

  1. error / errorString
    获取最近发生的错误类型及描述：

    QLocalSocket::LocalSocketError error() const;
QString errorString() const;

  2. waitForReadyRead / waitForBytesWritten
    阻塞当前线程，直到有数据可读或所有数据已写入套接字：

    bool waitForReadyRead(int msecs = 30000);
bool waitForBytesWritten(int msecs = 30000);

五、信号（异步通知）

  1. connected
    当连接建立时触发：

    void connected();

  2. disconnected
    当连接断开时触发：

    void disconnected();

  3. readyRead
    当有数据可读时触发：

    void readyRead();

  4. errorOccurred
    当发生错误时触发，携带错误类型：

    void errorOccurred(QLocalSocket::LocalSocketError socketError);

  5. stateChanged
    当套接字状态变化时触发，携带新状态：

    void stateChanged(QLocalSocket::LocalSocketState socketState);

六、示例代码

客户端示例：

QLocalSocket socket;
socket.connectToServer("my_server");
if (socket.waitForConnected()) {
    socket.write("Hello, Server!");
    socket.flush();
    if (socket.waitForReadyRead()) {
        qDebug() << "Server response:" << socket.readAll();
    }
    socket.disconnectFromServer();
} else {
    qDebug() << "Connection failed:" << socket.errorString();
}

服务端示例（配合 QLocalServer）：

QLocalServer server;
server.listen("my_server");
connect(&server, &QLocalServer::newConnection, [&]() {
    QLocalSocket *client = server.nextPendingConnection();
    connect(client, &QLocalSocket::readyRead, [client]() {
        qDebug() << "Received:" << client->readAll();
        client->write("Hello, Client!");
    });
});

通过以上接口和信号，QLocalSocket 提供了完整的本地进程间通信解决方案，适用于需要高效、低延迟的本地数据传输场景。

3.QLocalSocket的构成 

QLocalSocket的构成分析

QLocalSocket是Qt框架中用于本地进程间通信（IPC）的核心类，其构成可从以下几个方面进行详细解析：

1. 继承关系与基类

  • 继承自QIODevice：
    QLocalSocket继承自QIODevice，这使其具备流式读写数据的能力，支持通过read()、write()等方法进行数据传输，并可通过bytesAvailable()和bytesToWrite()监控数据缓冲状态。

  • Qt Network模块的一部分：
    作为Qt Network模块的组件，QLocalSocket封装了底层系统API（如Windows的命名管道和Unix的域套接字），提供跨平台的IPC支持。

2. 核心接口与功能

连接管理

  • connectToServer：
    尝试连接到指定名称的本地服务器，支持同步（waitForConnected）和异步（connected信号）连接机制。 
    void connectToServer(const QString &name, QIODeviceBase::OpenMode openMode = QIODeviceBase::ReadWrite);
  • disconnectFromServer / abort：
    断开连接或立即终止连接，清空未处理的数据。 

    void disconnectFromServer();
void abort();
  • waitForConnected：
    阻塞当前线程，直到连接建立或超时（默认30秒）。 
    bool waitForConnected(int msecs = 30000);

数据传输

  • write / read / readAll：
    实现数据的发送和接收，支持读取全部数据或指定字节数。 

    qint64 write(const QByteArray &data);
QByteArray read(qint64 maxSize);
QByteArray readAll();
  • flush：
    确保写缓冲区中的数据尽可能多地写入套接字。 
    bool flush();

状态查询

  • state：
    返回当前状态（如UnconnectedState、ConnectedState）。 
    QLocalSocket::LocalSocketState state() const;
  • isValid：
    检查套接字是否有效（即是否已成功打开）。 
    bool isValid() const;
  • bytesAvailable / bytesToWrite：
    监控数据缓冲状态，返回可立即读取或尚未写入的字节数。 

    qint64 bytesAvailable() const;
qint64 bytesToWrite() const;

错误处理

  • error / errorString：
    获取最近发生的错误类型及描述。 

    QLocalSocket::LocalSocketError error() const;
QString errorString() const;

  • errorOccurred信号：
    当发生错误时触发，携带错误类型。 
    void errorOccurred(QLocalSocket::LocalSocketError socketError);

3. 信号与异步机制

QLocalSocket支持事件驱动编程，通过信号与槽函数连接实现非阻塞通信：

  • connected：连接成功时触发。
  • disconnected：连接断开时触发。
  • readyRead：有数据可读时触发。
  • stateChanged：状态变化时触发，携带新状态。
  • errorOccurred：错误发生时触发。

4. 系统交互与底层实现

Windows实现

  • 命名管道（Named Pipe）：
    使用Windows系统API（如CreateNamedPipe、ConnectNamedPipe）创建和监听连接，通过命名管道实现进程间通信。

Unix-like系统实现

  • 域套接字（Unix Domain Socket）：
    利用Unix系统调用（如socket、bind、listen）创建本地套接字，通过文件路径（如/tmp/my_socket）标识服务。

跨平台封装

  • Qt封装了系统差异，提供统一的API接口，开发者无需关心底层实现细节。例如，connectToServer在Windows和Unix下分别映射为命名管道和域套接字的操作。

5. 与QLocalServer的协作

  • QLocalServer的作用：
    QLocalServer负责监听客户端连接，通过newConnection信号通知有新客户端接入，并通过nextPendingConnection方法获取客户端套接字（QLocalSocket实例）。

  • 协作流程：

    1. 服务器端：调用listen()监听指定名称，通过newConnection信号处理新连接，使用nextPendingConnection()获取客户端套接字。
    2. 客户端：调用connectToServer()连接到服务器，通过信号或同步方法处理数据传输。

6. 内部结构与成员变量

  • pimpl模式：
    采用指针指向实现对象（pimpl），隐藏底层系统句柄和平台相关细节，如系统套接字描述符（socketDescriptor）。

  • 关键成员变量：

    • socketDescriptor：指向底层系统套接字的句柄。
    • state：当前连接状态（如ConnectedState）。
    • error：最近发生的错误类型。
    • readBuffer / writeBuffer：读写缓冲区，用于临时存储数据。

7. 示例代码

客户端示例

QLocalSocket socket;
socket.connectToServer("my_server");
if (socket.waitForConnected()) {
    socket.write("Hello, Server!");
    socket.flush();
    if (socket.waitForReadyRead()) {
        qDebug() << "Server response:" << socket.readAll();
    }
    socket.disconnectFromServer();
} else {
    qDebug() << "Connection failed:" << socket.errorString();
}

服务端示例

QLocalServer server;
server.listen("my_server");
connect(&server, &QLocalServer::newConnection, [&]() {
    QLocalSocket *client = server.nextPendingConnection();
    connect(client, &QLocalSocket::readyRead, [client]() {
        qDebug() << "Received:" << client->readAll();
        client->write("Hello, Client!");
    });
});

结论

QLocalSocket的构成涵盖了继承关系、核心接口、信号机制、系统交互、与QLocalServer的协作以及内部实现细节。这些要素共同支撑起其在Qt框架中实现高效、跨平台的本地进程间通信功能，适用于需要快速、低延迟数据传输的场景。

 

基于 QLocalSocket 、QLocalServer 的进程间通信。
Jimmy的小黑屋
01-16 6565
基础： QLocalSocket 是本地 socket client 端，在 windows 里是用有名管道实现的，在 unix 里是本地域名socket实现的。 QLocalSocket 是事件驱动的，但也可以通过 waitFor… 系列方法阻塞使用。 QLocalServer 提供了本地 socket server 端。跟一般的 socket 使用方式类似：创建 对象，listen，wait ...
QLocalSocket Class 详解
抟土成人祖，炼石补青天。眼中览银河，手可摘星辰。
02-15 669
是 Qt 提供的一个非常有用的类，用于处理进程间通信，它提供了便捷的接口来创建、管理和关闭本地套接字连接。适用于需要进程间数据传输的场景，能够为开发人员提供低延迟、高效的通信机制。
Qt QLocalServer QLocalSocket进程通信实例
03-29
Qt使用QLocalServer和QLocalSocket进行进程间通讯的实例，与QTcpSocket和QUdpSocket不同的是，QLocalServer和QLocalSocket使用pipe管道通讯，可以方便的建立后台本地服务器响应其他进程。
QLocalSocket
abby_sheen的专栏
06-01 4824
QLocalSocket类提供了一个本地套接字。 在Windows这是一个命名管道,在Unix下这是一个本地网域套接字。 如果发生错误，socketError（）返回错误的类型，errorString（）返回错误的描述。 虽然QLocalSocket是一个事件循环使用而设计，它也可以不被如此使用。在这种情况下，您必须使用waitForConnected（），waitForReadyRead（
Qt QLocalSocket入门用法浅解
最新发布
jongden的专栏
10-09 852
QLocalSocket是Qt中​​轻量、高效的本地IPC方案​​，完美适配ZynqMP等嵌入式Linux设备。其核心是​​C/S架构​​，通过监听、连接，配合实现结构化数据传输。使用时需注意​​权限、资源清理、实时性优化​​，尤其适合嵌入式设备的进程间通信场景（如UI与核心逻辑分离、单实例应用）。并不是做什么事都非得有意义。请允许自己做一些无脑，无意义的事，比如说：目送一朵云。
QT之QLocalSocket下的两进程互相守护
yanchenyu365的博客
08-04 589
利用QLocalSocket封装GuardianService类，通过简单配置即可实现进程间的相互守护。
Qt网络编程：QLocalSocket
友善啊，朋友的博客
06-24 3800
一、描述 此类在 Windows 上这是一个命名管道，在 Unix 上这是一个本地域socket。（命名管道和本地域socket都用于进程间通信） 二、类型成员 1、QLocalSocket::LocalSocketError：此枚举表示可能发生的错误。最近的错误可通过调用error() 来检索。 ConnectionRefusedError：连接被对等方拒绝（或超时）。 PeerClosedError：远程套接字关闭了连接。 请注意，客户端套接字（即此套接字）将在发送远程关闭通知后关闭。 Se
Qt进程间通信QLocalSocket客户端无法接收消息
clhuang的博客
06-12 632
连接和服务端发送均正常，此时问题定位到客户端这边，检查代码，客户端连接服务端读写数据方式有问题，此处写成了QIODevice::WriteOnly，数据接收的方式应为QIODevice::ReadOnly。使用QLocalSocket和QLocalServer实现进程间通信，客户端和服务端连接建立成功，服务端消息发送也正常，但客户端无法接收服务端发送过来的消息。
Qt之QLocalSocket
weixin_33747129的博客
08-29 793
简述 QLocalSocket类提供了一个本地socket。 在Windows中，这是一个命名管道；在Unix中，这是一个本地网域socket。 如果发生错误，socketError()会返回错误的类型，errorString()则返回人类可读的错误描述。 虽然QLocalSocket是一个事件循环使用而设计，它也可以不被如此...
进程通信(IPC)之QLocalSocket用法
宁静致远的博客
03-15 3965
@TOC 原文链接：https://blog.youkuaiyun.com/fangye945a/article/details/106006819 进程通信(IPC)的方法有很多，项目开发中，需要根据业务需求来选择适合的IPC方式。所谓LocalSocket，其实就是在socket的基础上衍生出来的一种IPC通信机制。其旨在解决同一台主机上不同进程间互相通信的问题，不能像网络通信使用的socket一样实现不同主机间通信。但正因为这一点，它不需要经过网络协议栈，不需要打包拆包、计算校验，所以执行效率要更高。 而Qt对
Qt中的QTcpSocket、QWebSocket和QLocalSocket
03-07
这种服务通常使用`QTcpServer`或`QLocalServer`来监听新的连接，并创建对应的`QTcpSocket`或`QLocalSocket`实例来处理每个客户端的通信。 文件`MCommServerTest`和`MCommClientTest`可能分别是服务器端和客户端的...
QLocalServer_QLocalSocket.rar
02-18
实现qt程序之间的进程间通信，采用的方式是QLocalServer和QLocalSocket.其方式是通过加载dll的方式。动态链接库里封装了服务端和客户端的功能。
QT使用localsocket通信
06-09
QT的localsocket，包含服务端和客户端，本地管道通信。
ipc.rar_ ipc QT_QLocalSocket_QLocalSocket client_QSharedmemory_Q
09-21
在“ipc.rar”压缩包中，我们可以找到与这些知识点相关的代码示例或文档，它们可能包含如何在Windows环境下设置QLocalSocket服务器和客户端，以及如何利用QSharedMemory进行数据交换的实例。学习和理解这些示例，将...
Qt 如何实现单实例应用程序？
天恩软件工作室
09-11 1318
单例应用程序（Singleton Application）是一种特殊的应用程序设计方式，其核心思想是确保在同一时间只有一个应用程序实例在运行。这种设计方式在多种场景下具有显著的优势和应用价值。 在Qt中实现单实例应用程序通常涉及到检查是否已经有一个实例在运行，并在需要时与之通信。这可以通过多种方法实现，如是使用本地服务器（如QLocalServer）或文件锁（如QLockFile）等。
Qt进程间通信：QLocalServer与QLocalSocket实例解析
标题中提到的“QLocalServer QLocalSocket进程通信实例”直接涉及到了Qt框架中的本地IPC机制，下面将详细地解读这些知识点。 ### QLocalServer和QLocalSocket的概述 QLocalServer是一个用于实现本地IPC的服务器端...
QT示例学习之QLocalSocket
征途人生&梦
05-18 1150
服务端头文件 #ifndef SERVER_H #define SERVER_H #include <QWidget> #include <QLabel> #include <QPushButton> #include <QLocalServer> class Server : public QWidget { Q_OBJECT public: explicit Server(QWidget *parent = nullptr);
Qt本地进程间通信QLocalSocket
风起时~微凉的博客
05-27 1621
Qt提供本地基于socket实现的进程间通信，具体示例如下; 1、服务器端头文件 #ifndef LOCALSOCKETSERVER_H #define LOCALSOCKETSERVER_H #include <QObject> #include <QLocalServer> #include <QLocalSocket> #include <QDataStream> class LocalSocketServer : public QObject {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值