小项目试验：QProcess进程通讯 使用标准输入/输出流

已于 2025-07-16 14:35:48 修改
阅读量335 收藏 2
点赞数 2
CC 4.0 BY-SA版权
分类专栏： # c++ubuntu开发 文章标签： ubuntu qt 进程间通讯 标准输入输出 小项目试验
于 2025-06-30 09:59:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xie__jin__cheng/article/details/149016878

1.概要

需求：QProcess 启动的进程默认是子进程，父进程可通过其标准输入/输出流（stdin/stdout）与子进程通信，举一个完整的例子，使用c++，父进程直接打开子进程，可以使父子进程完成用不同的类执行，用一个程序，靠运行的输入参数区分父子进程。

代码要点梳理 ：

//父进程
{
    // 启动子进程
    process.start(program, args);
    
    // 等待子进程响应（同步方式）
    if (!process.waitForReadyRead(3000)) {
        qCritical() << "Timeout waiting for child response!";
        break;
    }

    // 写入子进程标准输入
    process.write(msg.toUtf8() + "\n");
    
    //子进程
    {
	    QTextStream in(stdin);
    	QTextStream out(stdout);

 		QString line = in.readLine().trimmed();

	    out << response << "\n";
       	out.flush();  // 确保立即输出
	}
    

    // 读取子进程输出
    QByteArray response = process.readAllStandardOutput();
}

2.内容

以下是一个使用C++和Qt的QProcess实现父子进程通信的完整示例。程序通过命令行参数区分角色，父子进程通过标准输入输出交换数据：

#include <QCoreApplication>
#include <QProcess>
#include <QTextStream>
#include <QDebug>
#include <QFile>

// 子进程处理函数
void runChildProcess() {
    QTextStream in(stdin);
    QTextStream out(stdout);

    qDebug() << "[Child] Started with PID:" << QCoreApplication::applicationPid();

    while (!in.atEnd()) {
        QString line = in.readLine().trimmed();
        if (line.isEmpty()) continue;

        // 示例处理：转换为大写并添加PID前缀
        QString response = QString("[%1] Response: %2")
                               .arg(QCoreApplication::applicationPid())
                               .arg(line.toUpper());

        out << response << "\n";
        out.flush();  // 确保立即输出
    }
}

// 父进程处理函数
void runParentProcess() {
    QProcess process;
    QString program = QCoreApplication::applicationFilePath();
    QStringList args;
    args << "child_process";  // 任意非空参数标识子进程

    // 启动子进程
    process.start(program, args);
    if (!process.waitForStarted()) {
        qCritical() << "Failed to start child process!";
        return;
    }

    qDebug() << "[Parent] Started with PID:" << QCoreApplication::applicationPid();

    // 发送测试数据
    QStringList testMessages = {
        "hello from parent",
        "Qt IPC example",
        "12345"
    };

    for (const QString& msg : testMessages) {
        // 写入子进程标准输入
        process.write(msg.toUtf8() + "\n");

        // 等待子进程响应（同步方式）
        if (!process.waitForReadyRead(3000)) {
            qCritical() << "Timeout waiting for child response!";
            break;
        }

        // 读取子进程输出
        QByteArray response = process.readAllStandardOutput();
        qDebug() << "[" << QCoreApplication::applicationPid()
                 << "] Received:" << response.trimmed();
    }

    // 关闭输入并等待结束
    process.closeWriteChannel();
    process.waitForFinished();
}

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

    if (argc > 1) {  // 有参数时作为子进程
        runChildProcess();
    } else {         // 无参数时作为父进程
        runParentProcess();
    }

    return 0;
}

使用说明：

  1. 保存为process_comm.cpp使用Qt的qmake编译： 

    qmake -project
qmake
make
    运行方式：
    • 父进程模式：./process_comm --parent
    • 子进程模式：./process_comm --child

示例输出：

[Parent] Started with PID: 448426
[ 448426 ] Received: "[448427] Response: HELLO FROM PARENT"
[ 448426 ] Received: "[448427] Response: QT IPC EXAMPLE"
[ 448426 ] Received: "[448427] Response: 12345"

代码分析： 

关键点说明：

  1. 进程区分：通过命令行参数--parent和--child区分角色
  2. 进程启动：
    • 父进程使用QProcess::start()启动自身程序并附加--child参数
    • QCoreApplication::applicationFilePath()确保正确获取可执行文件路径
  3. 通信机制：
    • 父进程通过process.write()发送数据
    • 子进程使用QTextStream读取标准输入
    • 双方通过标准输出交换数据
  4. 同步控制：
    • 使用waitForReadyRead()实现同步通信
    • closeWriteChannel()通知子进程输入结束
  5. 错误处理：
    • 检查进程启动状态
    • 设置超时机制防止死锁
    • 输出详细的调试信息

扩展建议：

  • 添加更复杂的通信协议（如JSON消息格式）
  • 实现异步通信（使用信号槽机制）
  • 添加错误恢复机制
  • 支持多线程处理多个子进程

这个示例演示了基本的进程间通信模式，可根据具体需求扩展通信协议和处理逻辑。

3.关联链接

4.管理知识

1.QProcess::start详解

QProcess::start() 是 Qt 框架中用于启动外部进程的核心方法，支持多种重载形式以适应不同场景。以下是详细解析：

函数原型

// 基础重载（程序名 + 参数列表）
bool QProcess::start(const QString &program, const QStringList &arguments = QStringList(), 
OpenMode mode = ReadWrite);


// 带工作目录的重载
bool QProcess::start(const QString &program, const QStringList &arguments, 
const QString &workingDirectory);


// 带环境变量的重载
bool QProcess::start(const QString &program, const QStringList &arguments, 
OpenMode mode, const QIODevice::OpenMode &ioMode);

参数详解

  1. program
    • 要启动的外部程序路径（绝对路径或可执行文件名）。
    • 跨平台注意：Windows 需包含 .exe 后缀（如 "notepad.exe"），Linux/macOS 可直接写命令（如 "ls"）。
  2. arguments
    • 命令行参数列表，按顺序传递。
    • 示例：QStringList() << "-f" << "input.txt" 对应命令 program -f input.txt。
  3. workingDirectory（可选）
    • 设置进程的工作目录，影响相对路径的解析。
  4. mode（可选）
    • 控制进程的输入/输出模式，默认为 ReadWrite（可读写）。
    • 其他选项：ReadOnly（只读）、WriteOnly（只写）、Unbuffered（禁用缓冲）。

执行模式

1. 异步执行（默认）
  • start() 立即返回，进程在后台运行。
  • 通过信号槽处理输出和结束事件： 

    QProcess process;
process.start("ping", {"-c", "4", "example.com"});


connect(&process, &QProcess::readyReadStandardOutput, [&](){
    qDebug() << "输出：" << process.readAllStandardOutput();
});


connect(&process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
[](int exitCode, QProcess::ExitStatus status){
    qDebug() << "进程结束，退出码：" << exitCode;
});
2. 同步执行
  • 使用 waitForStarted() 阻塞当前线程，直到进程启动： 

    if (process.start("ping", {"-c", "4", "example.com"}) && process.waitForStarted()) {
    process.waitForFinished(); // 等待进程结束
    QString output = process.readAllStandardOutput();
}

返回值

  • 返回 bool 类型，表示进程是否成功启动。
  • 失败时可通过 errorString() 获取原因： 

    if (!process.start("non_existent_program")) {
    qDebug() << "启动失败：" << process.errorString();
}

常见用例

1. 启动带参数的程序

QProcess process;
process.start("ffmpeg", {"-i", "input.mp4", "-c:v", "libx264", "output.mp4"});
2. 指定工作目录
process.start("python", {"script.py"}, "/path/to/working/dir");
3. 传递环境变量

QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("CUSTOM_VAR", "value");
process.setProcessEnvironment(env);
process.start("my_app");

注意事项

  1. 路径问题
    • 优先使用绝对路径，或确保程序在系统 PATH 中。
    • Windows 示例：C:\\Windows\\System32\\notepad.exe（注意转义反斜杠）。
  2. 阻塞风险
    • 避免在 GUI 主线程中使用同步模式（waitFor*），否则会导致界面卡顿。
  3. 输出处理
    • 异步模式下需及时读取输出，或通过信号实时处理，防止缓冲区溢出。
  4. 跨平台差异
    • 命令行参数格式可能不同（如 Windows 用 / 而 Linux/macOS 用 -）。

高级技巧

  • 重定向输入/输出

    process.setStandardInputFile("input.txt");
process.setStandardOutputFile("output.txt");

  • 后台进程（不关联父进程）

    QProcess::startDetached("program", arguments, workingDirectory, &pid);

通过合理使用 QProcess::start()，可以灵活集成外部工具到 Qt 应用中，实现文件操作、网络诊断、自动化测试等复杂功能。

2.QProcess 管道 通讯，只能是父子进程间通讯吗

QProcess 的管道通信不局限于父子进程间，但需结合操作系统特性或设计模式实现。以下是详细解析：

1. QProcess 默认行为

QProcess 启动的进程默认是子进程，父进程可通过其标准输入/输出流（stdin/stdout）与子进程通信。例如：

QProcess processA;
processA.start("programA"); // 启动子进程A


QProcess processB;
processB.start("programB"); // 启动子进程B


// 父进程将A的输出转发给B的输入
connect(&processA, &QProcess::readyReadStandardOutput, [&]() {
    QByteArray data = processA.readAllStandardOutput();
    processB.write(data); // 手动传递数据
});

2. 非父子进程间管道通信

若需让两个独立进程（非父子）直接通过管道通信，需借助操作系统特性：

方案 1：命名管道（Named Pipe/FIFO）
  • 步骤：
    1. 创建命名管道（如 /tmp/my_pipe）。
    2. 进程A向管道写入数据，进程B从管道读取。
  • 示例代码： 

    // 进程A（写入端）
QProcess processA;
processA.start("programA", {"--output-pipe", "/tmp/my_pipe"});


// 进程B（读取端）
QProcess processB;
processB.start("programB", {"--input-pipe", "/tmp/my_pipe"});

方案 2：Shell 管道符（仅限命令行启动）
  • 通过系统 Shell 的管道符 | 直接连接两个进程： 

    QProcess process;
process.start("programA | programB"); // Linux/macOS 示例
// Windows 需使用 cmd /C "programA | programB"

3. QProcess 的局限性

  • 无法直接连接子进程管道：QProcess 不提供内置方法将两个子进程的管道直接连接（如 programA | programB 需通过系统 Shell 实现）。
  • 需手动中转数据：若需在 Qt 代码中实现子进程间通信，需通过父进程读取一个进程的输出并写入另一个进程的输入（如示例1）。

4. 推荐方案

场景方案优点缺点
简单子进程间通信父进程手动中转数据兼容所有平台需编写中转逻辑
跨平台独立进程通信命名管道 + 第三方库（如 Boost）完全解耦需处理同步和错误
命令行工具链式调用Shell 管道符代码简洁仅限命令行启动

总结

  • 父子进程间：QProcess 可直接通过 stdin/stdout 通信。
  • 非父子进程间：需借助命名管道、套接字或系统 Shell 管道符，QProcess 不直接支持但可配合使用。
  • 最佳实践：优先通过父进程中转数据实现简单通信，复杂场景建议使用专用 IPC 机制（如 ZeroMQ、共享内存）。

3.QProcess 管道可以进行二次通讯 

QProcess 的管道通信支持多次双向交互，并非仅限单次消息传递。以下是详细说明：

1. QProcess 管道通信原理

  • 标准流重定向：QProcess 默认将子进程的 stdin/stdout/stderr 映射到父进程的管道。
  • 双向通信：父进程可随时通过 write() 向子进程发送数据，子进程也可通过 stdout 持续输出结果。

2. 实现多次通信的示例

父进程代码

QProcess process;
process.start("child_app"); // 启动子进程

// 发送第一条消息
process.write("Hello from Parent!\n"); // 注意添加换行符（若子进程按行读取）
process.flush(); // 确保数据立即发送

// 读取子进程响应
if (process.waitForReadyRead()) {
    QString response = process.readAllStandardOutput();
    qDebug() << "子进程回复：" << response;
}

// 发送第二条消息
process.write("Another message!\n");
process.flush();

// 再次读取响应
if (process.waitForReadyRead()) {
    QString response2 = process.readAllStandardOutput();
    qDebug() << "子进程二次回复：" << response2;
}

process.close(); // 关闭进程
子进程代码（child_app）

#include <QCoreApplication>
#include <QTextStream>

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);
    QTextStream in(stdin);
    QTextStream out(stdout);

    while (!in.atEnd()) {
        QString line = in.readLine(); // 按行读取父进程输入
        out << "收到: " << line << "\n"; // 回复父进程
        out.flush(); // 确保立即发送
    }

    return a.exec();
}

3. 关键点

  1. 持续读写
    • 父进程可多次调用 write() 发送数据，子进程通过循环（如 while (!in.atEnd())）持续接收。
    • 子进程的每次输出都会触发父进程的 readyReadStandardOutput 信号（若使用异步模式）。
  2. 缓冲区管理
    • 使用 flush() 确保数据立即发送，避免因缓冲区未满导致延迟。
    • 父进程需及时读取子进程输出，防止阻塞子进程（尤其在使用 waitForReadyRead 时）。
  3. 协议设计
    • 定义明确的消息边界（如换行符 \n 或固定长度），避免数据粘连。
    • 可使用 QDataStream 传输结构化数据（如 JSON、二进制协议）。

4. 异步模式优化

父进程（异步）

QProcess process;
process.start("child_app");

// 连接子进程输出信号
connect(&process, &QProcess::readyReadStandardOutput, [&]() {
    QString response = process.readAllStandardOutput();
    qDebug() << "子进程回复：" << response;
});

// 发送消息（非阻塞）
process.write("Async message 1\n");
process.flush();

// 稍后再次发送
QTimer::singleShot(1000, [&]() {
    process.write("Async message 2\n");
    process.flush();
});
子进程（同上）

5. 注意事项

  • 进程生命周期：子进程退出后，管道自动关闭，无法继续通信。
  • 错误处理：检查 QProcess::error() 和 QProcess::exitStatus() 处理异常。
  • 跨平台行为：Windows 下子进程可能继承父进程的控制台，需测试输出行为。

总结

QProcess 管道通信完全支持多次双向交互，关键在于：

  1. 子进程设计为持续监听输入（如循环读取）。
  2. 父进程及时读写数据，避免缓冲区阻塞。
  3. 定义清晰的消息协议确保数据完整性。

此机制适用于命令行工具集成、实时日志处理等场景，性能优于本地套接字（因无系统调用开销）。

4.标准输入输出流的宏，Windows 平台的 C/C++ 开发环境

#ifndef _STDSTREAM_DEFINED
#define stdin (__acrt_iob_func(0))
#define stdout (__acrt_iob_func(1))
#define stderr (__acrt_iob_func(2))
#define _STDSTREAM_DEFINED
#endif

这段代码是用于在 Microsoft Visual C++ 运行时库（CRT）中定义标准输入输出流的宏，常见于 Windows 平台的 C/C++ 开发环境。以下是逐行解释：

  1. #ifndef _STDSTREAM_DEFINED
    • 条件编译指令，检查 _STDSTREAM_DEFINED 宏是否未定义。如果未定义，则处理后续代码块，防止重复包含。
  2. #define stdin (__acrt_iob_func(0))
    • 定义 stdin 宏，指向标准输入流。__acrt_iob_func 是微软 CRT 的内部函数，参数 0 表示标准输入（stdin）。
  3. #define stdout (__acrt_iob_func(1))
    • 定义 stdout 宏，指向标准输出流。参数 1 表示标准输出（stdout）。
  4. #define stderr (__acrt_iob_func(2))
    • 定义 stderr 宏，指向标准错误流。参数 2 表示标准错误（stderr）。
  5. #define _STDSTREAM_DEFINED
    • 标记标准流已定义，防止后续重复定义。
  6. #endif
    • 结束条件编译块。

作用说明：

  • 兼容性处理：微软的 CRT 在某些情况下（如宽字符模式或特定编译选项）需要特殊处理标准流，通过 __acrt_iob_func 函数获取对应的 FILE* 指针。
  • 隐藏实现细节：将底层实现封装在宏中，使代码对用户透明。
  • 防止重复定义：通过 _STDSTREAM_DEFINED 宏确保这些定义只生效一次。

典型使用场景：

当需要直接操作 stdin/stdout/stderr 的底层实现时（如重定向流、调试或特定 I/O 操作），这段代码提供了跨编译模式的统一访问方式。

5.C语言标准库中关于标准输入输出流

/* Standard streams.  */
extern FILE *stdin;		/* Standard input stream.  */
extern FILE *stdout;		/* Standard output stream.  */
extern FILE *stderr;		/* Standard error output stream.  */
/* C89/C99 say they're macros.  Make them happy.  */
#define stdin stdin
#define stdout stdout
#define stderr stderr

这段代码是C语言标准库中关于标准输入输出流的典型实现，主要目的是同时满足标准规范要求和实际工程需求。以下是分步解释：

  1. 标准流声明

extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;
  • 声明三个全局FILE指针变量，分别对应：
    • stdin：标准输入流（默认关联键盘）
    • stdout：标准输出流（默认关联控制台）
    • stderr：标准错误流（默认关联控制台，允许无缓冲输出）
  • extern关键字表示这些变量在其他源文件中定义（如C标准库实现文件）
  1. 标准兼容性宏定义

#define stdin stdin
#define stdout stdout
#define stderr stderr
  • 看似冗余的宏定义，实为满足C89/C99标准要求：
    • 标准规定这三个符号必须作为宏存在
    • 同时允许它们也可以作为变量存在
    • 这种"自引用宏"实现方式既保持标准兼容，又不影响实际变量访问
  1. 设计意图解析
  • 双模式访问：允许通过两种方式访问标准流： 

    // 通过变量直接操作
fprintf(stdout, "Hello");


// 通过宏（可能被重定向）
#define stdout my_log_file
fprintf(stdout, "Debug");

  • 底层实现分离：
    • 实际实现中，这些变量可能通过系统调用（如Unix的fileno(0/1/2)）关联标准文件描述符
    • 宏定义留有扩展空间，例如某些实现可能通过宏实现线程局部存储或重定向功能
  1. 典型应用场景
  • 标准I/O操作：printf()/scanf()等函数底层通过这些流进行输入输出
  • 流重定向：通过修改宏定义实现运行时重定向（如将stdout重定向到文件）
  • 跨平台兼容：不同操作系统（Windows/Linux/macOS）通过统一接口抽象底层差异
  1. 与MSVC实现的对比
  • 之前示例的Microsoft实现通过__acrt_iob_func函数动态获取流指针，而本示例采用静态声明
  • 两种方式都是标准允许的实现方式，区别在于：
    • MSVC方式更灵活（支持运行时配置）
    • 本示例方式更直接（适合静态链接场景）

这种实现模式是C标准库设计的经典范例，通过巧妙的宏定义在保持标准兼容性的同时，提供了实际可用的变量接口，兼顾了规范要求和工程实用性。

6.stdin和stdout是什么 

stdin 和 stdout 是计算机编程中的两个核心概念，属于标准输入输出流的范畴。以下是分步解释：

1. 定义与作用

  • stdin（Standard Input）
    • 标准输入流，默认关联键盘输入。
    • 程序通过它读取用户输入的数据（例如：scanf()、fgets() 等函数）。
  • stdout（Standard Output）
    • 标准输出流，默认关联屏幕显示。
    • 程序通过它输出结果（例如：printf()、puts() 等函数）。
  • stderr（Standard Error）
    • 标准错误流，默认也关联屏幕，但用于输出错误信息（可与 stdout 分离重定向）。

2. 是否所有应用程序都有？

不是所有应用程序都直接使用它们，但绝大多数命令行工具和终端程序会依赖这些流。具体取决于程序类型和运行环境：

情况 1：命令行程序（如 ls, grep, Python 脚本等）
  • 必然使用：这些程序默认通过终端交互，stdin/stdout 是它们与用户沟通的唯一通道。
  • 示例： 

    $ echo "Hello" | ./my_program # 将 "Hello" 通过 stdin 输入给程序
$ ./my_program > output.txt # 将 stdout 重定向到文件
情况 2：图形界面程序（如记事本、浏览器等）
  • 通常不直接使用：它们通过窗口、按钮等 GUI 元素交互，而非终端输入输出。
  • 例外：某些 GUI 程序可能通过子进程调用命令行工具，间接使用 stdin/stdout。
情况 3：后台服务/守护进程（Daemon）
  • 可能无关联：如果程序完全脱离终端运行（如 Web 服务器），stdin/stdout 可能被重定向到文件或关闭。
情况 4：嵌入式系统或无操作系统环境
  • 不存在：在资源受限的环境中，可能没有标准库支持，因此无 stdin/stdout 概念。

3. 跨平台差异

  • 类 Unix 系统（Linux/macOS）：
    所有进程启动时默认打开 stdin（文件描述符 0）、stdout（1）、stderr（2），即使无终端（如通过 cron 运行的任务）。

  • Windows：
    CMD/PowerShell 中的程序类似 Unix，但某些 GUI 应用可能不继承控制台流（需通过 AllocConsole() 显式创建）。

4. 编程语言中的表现

  • C/C++：直接操作 FILE* 指针（如 stdin/stdout 宏）。
  • Python：通过 sys.stdin/sys.stdout 对象访问。
  • Java：通过 System.in/System.out 对象访问。

总结

  • stdin/stdout 是标准 I/O 的抽象接口，为程序提供统一的输入输出方式。
  • 绝大多数命令行工具和终端程序依赖它们，但图形界面、后台服务或嵌入式程序可能不直接使用。
  • 它们的存在性取决于程序类型、运行环境和操作系统支持。

QT软件开发: QProcess启动进程完成交互并获取输出
07-28 5780
一、QProcess介绍 QProcess类用于启动外部程序并与它们通信。 QProcess允许将进程视为I/O设备。可以像使用qtcsocket访问网络连接一样对进程进行写入和读取。然后可以通过调用write()写入进程的标准输入，并通过调用read()、readLine()和getChar()读取标准输出。因为QProcess继承了QIODevice，所以它还可以用作QXmlReader的输入源，或者用于生成要使用QNetworkAccessManager上载的数据。 当进程退出时，QProces
Qt/QML编程之路：QProcess进程创建（27）
码农17年的博客
01-07 1254
可以通过调用write()写入进程的标准输入，并通过调用read()、readLine()和getChar()读取标准输出。finished()信号提供进程的退出代码和退出状态作为参数，也可以调用exitCode()来获得最后一个完成的进程的退出码，调用exitStatus()来获取其退出状态。默认情况下，进程在调用进程的当前工作目录中运行。频道channel的术语可能具有误导性，请注意，进程的输出通道与QProcess的读取通道相对应，而进程的输入通道与QPprocess的写入通道相对应。
QT父子进程间通讯
01-28
QT父子进程间通讯，父进程通过writeData发送数据，子进程通过读取标准输入获取数据。
QT信号(槽)重载：QProcess、connect、QOverload
08-15 606
QT信号(槽)重载：QProcess、connect、QOverload
Qt 的内部进程通信机制
fh400的专栏
05-12 749
       在 Qt 系统中，不仅有着构造完善的系统结构，而且为了满足用户对编写图形用户界面应用的种种需求，它还创建了许多新的系统机制，其中 Qt 所特有的内部进程通信机制尤其值得一提。 本文分析了基于 QT 的应用进程之间通信常用的三种机制：QCOP 协议，Signal-Slot 机制和 FIFO 机制。给出了各自的使用方法，并指出了各自的使用场合。 1、 QCOP协议       
QT笔记——QProcess学习
lion_cxq的博客
08-15 6935
2：当主进程关闭时，被调用的QTcpClientTest.exe 是随着主进程一起退出。3：主进程发送的参数，被调用的QTcpClientTest.exe 依然可以接受。3：主进程发送的参数，被调用的QTcpClientTest.exe 可以接受参数。(1.1)分离式:外部程序启动程序后，主程序退出时，被调用的进程继续执行，不退出。1：使用了startDetached来启动进程，信号都是无效的，接受不到任何消息。2：当主进程关闭时，被调用的QTcpClientTest.exe 是不会退出的。
QT进程间通信详细介绍及QProcess机制分析
热门推荐
fengel_cs的专栏
07-15 1万+
1、QT通信机制 为了更好的实现QT的信息交互，在QT系统中创建了较为完善的通信机制。QT的通信可分为QT内部通信和外部通信两大类。对于这两类通信机制及应用场合做如以下分析： （1）QT内部对象间通信 在图形用户界面编程中，经常需要将一个窗口部件的变化通知给窗口的其它部件使其产生相应的变化。对于这种内部对象间的通信，QT主要采用了信号和槽的机制。这种机制是QT区别于其他G
qt使用QProcess实现父子进程通信,适用linux平台
10-27
2. **父进程向子进程发送数据**：父进程可以通过设置QProcess的输出重定向，将数据写入子进程的标准输入。例如，使用`QProcess::write()`或`QProcess::putenv()`函数。 3. **子进程接收数据**：子进程可以通过读取...
Qt开发：QProcess的使用
TechNomad的博客
10-21 1560
本文介绍了QProcess的用法
Qt读写标准输入/输出流
daizhiyan1的博客
06-06 4597
答案：QFile和QTextSream QTextStream我没尝试过，可跳转： https://blog.youkuaiyun.com/haha_mingg/article/details/6884883 QFile可行，具体实例，可见https://blog.youkuaiyun.com/daizhiyan1/article/details/80596583里面对标准输入输出流的读写。 读取标准输入输出流的...
QT学习经验之父子通信
qq_46341303的博客
08-04 709
qt技巧
Qt外部调用进程类QProcess的使用
苍天愚弄我
03-02 3249
可以看到关闭后触发了对应finished()信号，然后通过打印可以看到状态从打开到关闭的变化情况是：1(Starting)->2(Running)->0(NotRunning)。并且触发finished()信号时由于进程已经关闭，所以获取不到对应的进程id，但是stateChanged(NotRunning)会先于finished()，并且这时进程没有完全关闭所有能获取到对应进程id。：是一个指向字符指针数组的指针，其中每个元素是一个指向表示一个命令行参数的C风格字符串的指针。
QProcess 启动 进程 传参数 启动控制台进程 传参
q610098308的专栏
12-02 1370
4、外部程序退出时，状态是NotRunning,并发出finished（）信号。5、外部程序发生错误时，Qprocess会发出一个error（）信号，可通过error（）来获得其错误类型，通过state（）获得当前程序的状态。3、外部程序启动之后，状态是Running,并发出started（）信号，此时可对QProcess进行RW操作；可以提前设置启动命令参数也可以不设置(非必须)，也可以在start方法中进行设置。外部程序启动后，当主程序退出时并不退出，而是继续运行。使用 startDetached。
QProcess调用外部程序
Frank的专栏
05-23 5081
QProcess调用外部程序的处理
Qt之进程通信-QProcess（含源码+注释）
lw的博客
10-04 4098
QProcess启动子进程后，主进程关闭会带着子进程一起关闭，但是如果通过startDetached启动子进程写入的数据将读取不到，大概如此，网络中还包含子进程使用QSocketNotifier关联数据读取，我个人并未尝试成功，后期打算再尝试一下。
QProcess 启动外部进程
最新发布
@
03-25 1355
QProcess是Qt框架中用于启动外部程序和**进程间通信（IPC）**的核心类，继承自QObject。它为开发者提供了跨平台的进程管理能力，支持Windows、Linux和macOS系统。
qt使用QProcess实现进程通信
liji_digital的博客
10-27 2301
qt使用QProcess实现进程通信
qt子进程和父进程读写数据通信
biao2488890051的博客
07-31 1393
进程A（例如主程序）创建了一个QProcess B，这个B就称为A的子进程，而A称为B的父进程。这里，因为是采用 QProcess创建的子进程，所以，接下来讲解的是该通信方式。子进程接收到了父进程数据，两个信号会发射出来：两个功能函数：QProcess::write()发出信息。
Qt：进程与进程间通信
yangchuankai's blog
10-11 985
eg:   //启动一个tar进程，打包备份某个路径下的所有内容。 int main(int argc, char *argv[]) {     QApplication a(argc, argv);     if(a.arguments().count() != 2){         qDebug()         return -1;                    
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值