精华内容
下载资源
问答
  • QProcess

    2021-08-24 21:58:10
    QProcess process = new QProcess(this); connect(process, SIGNAL(finished(int, QProcess::ExitStatus)),this, SLOT(finished(int, QProcess::ExitStatus))); QStringList list; QString program = "C:\\...

    简单使用:

    #pragma once
    
    #include <QtWidgets/QWidget>
    #include "ui_widget_server.h"
    #include <QProcess>
    class widget_server : public QWidget
    {
        Q_OBJECT
    
    public:
        widget_server(QWidget *parent = Q_NULLPTR);
        void onButtonClicked();
    
    public slots:
        void finished(int exitCode, QProcess::ExitStatus exitStatus);
        void stateChanged(QProcess::ProcessState newState);
        void started();
    private:
        Ui::widget_serverClass ui;
        QProcess *process = nullptr;
    };
    
    #include "widget_server.h"
    #include <QPushbutton>
    #include <QProcess>
    #include <QDebug>
    widget_server::widget_server(QWidget *parent)
        : QWidget(parent)
    {
        ui.setupUi(this);
        connect(ui.pushButton, &QPushButton::clicked, this, &widget_server::onButtonClicked);
    }
    
    void widget_server::onButtonClicked() {
      if (process == nullptr) {
        process = new QProcess(this);
     
        connect(process, SIGNAL(started()), this,SLOT(started()));
    
        connect(process, SIGNAL(finished(int, QProcess::ExitStatus)),this, SLOT(finished(int, QProcess::ExitStatus)));
    
        connect(process, SIGNAL(stateChanged(QProcess::ProcessState)), this,SLOT(stateChanged(QProcess::ProcessState)));
      }
    
      QStringList list;
      //list << "hello_1" << "world_2" << "ok_3";
    
      QString program = "C:\\Windows\\notepad.exe";
    
      process->start(program, list);
    
    }
    
    void widget_server::finished(int exitCode, QProcess::ExitStatus exitStatus)
    {
      qDebug() << "finished";
    
      qDebug() << exitCode;// 被调用程序的main返回的int
      qDebug() << exitStatus;// QProcess::ExitStatus(NormalExit)
      qDebug() << "finished-output-readAll:";
      qDebug() << QString::fromLocal8Bit(process->readAll());
      qDebug() << "finished-output-readAllStandardOutput:";
      qDebug() << QString::fromLocal8Bit(process->readAllStandardOutput());
    
    }
    
    void widget_server::started() {
      qDebug() << "started";
    }
    void widget_server::stateChanged(QProcess::ProcessState state) {
      qDebug() << "stateChanged";
      qDebug() << state;// 被调用程序的main返回的int
    }
    

    当notepad.exe退出时,会收到finished信号。那么QProcess是如何运行的呢?

    void QProcess::start(const QString &program, const QStringList &arguments, OpenMode mode)
    • 在新进程中启动给定的program,传递命令行 arguments中的参数。QProcess 对象将立即进入开始状态。
    • 如果进程启动成功,QProcess 会发出started();否则,errorOccurred() 将被发出。
    • 进程是异步启动的,这意味着started()和 errorOccurred() 信号可能会延迟。调用 waitForStarted() 使确保进程已启动(或启动失败)和那些信号已经发出。
    •  如果 QProcess 对象已经在运行一个进程,则可能会出现警告
    •  在控制台打印,现有进程将继续运行不受影响。
    void QProcess::start(const QString &program, const QStringList &arguments, OpenMode mode)
    {
        Q_D(QProcess);
        if (d->processState != NotRunning) {
            qWarning("QProcess::start: Process is already running");
            return;
        }
        if (program.isEmpty()) {
            d->setErrorAndEmit(QProcess::FailedToStart, tr("No program defined"));
            return;
        }
    
        d->program = program;//可执行文件路径
        d->arguments = arguments;//参数
    
        d->start(mode);
    }

    d即QProcessPrivate,d->start 到了:

    void QProcessPrivate::start(QIODevice::OpenMode mode)
    {
        Q_Q(QProcess);
    #if defined QPROCESS_DEBUG
        qDebug() << "QProcess::start(" << program << ',' << arguments << ',' << mode << ')';
    #endif
    
        //获取创建进程stdin stdout stderr 
        if (stdinChannel.type != QProcessPrivate::Channel::Normal)
            mode &= ~QIODevice::WriteOnly;     // not open for writing
        if (stdoutChannel.type != QProcessPrivate::Channel::Normal &&
            (stderrChannel.type != QProcessPrivate::Channel::Normal ||
             processChannelMode == QProcess::MergedChannels))
            mode &= ~QIODevice::ReadOnly;      // not open for reading
        if (mode == 0)
            mode = QIODevice::Unbuffered;
        if ((mode & QIODevice::ReadOnly) == 0) {
            if (stdoutChannel.type == QProcessPrivate::Channel::Normal)
                q->setStandardOutputFile(q->nullDevice());
            if (stderrChannel.type == QProcessPrivate::Channel::Normal
                && processChannelMode != QProcess::MergedChannels)
                q->setStandardErrorFile(q->nullDevice());
        }
    
        q->QIODevice::open(mode);
    
        if (q->isReadable() && processChannelMode != QProcess::MergedChannels)
            setReadChannelCount(2);
    
        stdinChannel.closed = false;
        stdoutChannel.closed = false;
        stderrChannel.closed = false;
    
        exitCode = 0;
        exitStatus = QProcess::NormalExit;
        processError = QProcess::UnknownError;
        errorString.clear();
        startProcess();//启动进程
    }

    void QProcessPrivate::startProcess()

    void QProcessPrivate::startProcess()
    {
        Q_Q(QProcess);
    
        bool success = false;
    
        if (pid) {
            CloseHandle(pid->hThread);
            CloseHandle(pid->hProcess);
            delete pid;
            pid = 0;
        }
        pid = new PROCESS_INFORMATION;
        memset(pid, 0, sizeof(PROCESS_INFORMATION));
    
        q->setProcessState(QProcess::Starting);
    
        if (!openChannel(stdinChannel) ||
            !openChannel(stdoutChannel) ||
            !openChannel(stderrChannel))
            return;
    
        QString args = qt_create_commandline(program, arguments);
        QByteArray envlist;
        if (environment.d.constData())
            envlist = qt_create_environment(environment.d.constData()->vars);
        if (!nativeArguments.isEmpty()) {
            if (!args.isEmpty())
                 args += QLatin1Char(' ');
            args += nativeArguments;
        }
    
    #if defined QPROCESS_DEBUG
        qDebug("Creating process");
        qDebug("   program : [%s]", program.toLatin1().constData());
        qDebug("   args : %s", args.toLatin1().constData());
        qDebug("   pass environment : %s", environment.isEmpty() ? "no" : "yes");
    #endif
    
        // We cannot unconditionally set the CREATE_NO_WINDOW flag, because this
        // will render the stdout/stderr handles connected to a console useless
        // (this typically affects ForwardedChannels mode).
        // However, we also do not want console tools launched from a GUI app to
        // create new console windows (behavior consistent with UNIX).
        DWORD dwCreationFlags = (GetConsoleWindow() ? 0 : CREATE_NO_WINDOW);
        dwCreationFlags |= CREATE_UNICODE_ENVIRONMENT;
        STARTUPINFOW startupInfo = { sizeof( STARTUPINFO ), 0, 0, 0,
                                     (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
                                     (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT,
                                     0, 0, 0,
                                     STARTF_USESTDHANDLES,
                                     0, 0, 0,
                                     stdinChannel.pipe[0], stdoutChannel.pipe[1], stderrChannel.pipe[1]
        };
    
        const QString nativeWorkingDirectory = QDir::toNativeSeparators(workingDirectory);
        QProcess::CreateProcessArguments cpargs = {
            0, (wchar_t*)args.utf16(),
            0, 0, TRUE, dwCreationFlags,
            environment.isEmpty() ? 0 : envlist.data(),
            nativeWorkingDirectory.isEmpty() ? Q_NULLPTR : (wchar_t*)nativeWorkingDirectory.utf16(),
            &startupInfo, pid
        };
        if (modifyCreateProcessArgs)
            modifyCreateProcessArgs(&cpargs);
        //创建进程
        success = CreateProcess(cpargs.applicationName, cpargs.arguments, cpargs.processAttributes,
                                cpargs.threadAttributes, cpargs.inheritHandles, cpargs.flags,
                                cpargs.environment, cpargs.currentDirectory, cpargs.startupInfo,
                                cpargs.processInformation);
    
        QString errorString;
        if (!success) {
            // Capture the error string before we do CloseHandle below
            errorString = QProcess::tr("Process failed to start: %1").arg(qt_error_string());
        }
    
        if (stdinChannel.pipe[0] != INVALID_Q_PIPE) {
            CloseHandle(stdinChannel.pipe[0]);
            stdinChannel.pipe[0] = INVALID_Q_PIPE;
        }
        if (stdoutChannel.pipe[1] != INVALID_Q_PIPE) {
            CloseHandle(stdoutChannel.pipe[1]);
            stdoutChannel.pipe[1] = INVALID_Q_PIPE;
        }
        if (stderrChannel.pipe[1] != INVALID_Q_PIPE) {
            CloseHandle(stderrChannel.pipe[1]);
            stderrChannel.pipe[1] = INVALID_Q_PIPE;
        }
    
        if (!success) {
            cleanup();
            setErrorAndEmit(QProcess::FailedToStart, errorString);
            q->setProcessState(QProcess::NotRunning);
            return;
        }
    
        q->setProcessState(QProcess::Running);
        // User can call kill()/terminate() from the stateChanged() slot
        // so check before proceeding
        if (!pid)
            return;
    
        //消息通知
        if (threadData->hasEventDispatcher()) {
            processFinishedNotifier = new QWinEventNotifier(pid->hProcess, q);
            QObject::connect(processFinishedNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_processDied()));
            processFinishedNotifier->setEnabled(true);
        }
    
        _q_startupNotification();
    }

    其中:CreateProcess https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa 调用windowapi创建进程;

    qt中的消息循环是线程相关的https://zhuanlan.zhihu.com/p/113695485,简单的说

    当我们创建一个QObject时,它会与创建自己所在的线程绑定。它参与的消息循环,其实是它所在线程的消息循环,如上图所示。假如某个线程没有默认的QThread::exec(),那么该线程上的QObject则无法接收到事件。另外,如果两个不同线程的QObject需要相互通信,那么只能通过QueuedConnection的方式,异步通知对方线程,在下一轮消息循环处理QObject的消息。

    bool QEventLoop::processEvents(ProcessEventsFlags flags)
    {
        Q_D(QEventLoop);
        if (!d->threadData->eventDispatcher)
            return false;
        if (flags & DeferredDeletion)
            QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
        return d->threadData->eventDispatcher->processEvents(flags);
    }

    原来QEventLoop作为一个QObject,它也有threadData。同一个线程threadData只创建一次,所以它们取出来的eventDispatcher也都是相同的。这意味着所有的相同线程的QObject,共享一份threadData,也就是同一份eventDispatcher, postEventList等。这也就说明了,我们上图是如何实现的

    QEventDispatcherWin32是跟着线程走的,所以没有必要每个QEventLoop都存一个。事实上,它存放在一个叫做QThreadData的结构中

        if (threadData->hasEventDispatcher()) {
            processFinishedNotifier = new QWinEventNotifier(pid->hProcess, q);
            QObject::connect(processFinishedNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_processDied()));
            processFinishedNotifier->setEnabled(true);
        }

    重点是:        processFinishedNotifier = new QWinEventNotifier(pid->hProcess, q);它创建了一个QWinEventNotifier,并且注册到eventDispatcher,也就是QEventDispatcherWin32

    QWinEventNotifier::QWinEventNotifier(HANDLE hEvent, QObject *parent)
     : QObject(*new QWinEventNotifierPrivate(hEvent, false), parent)
    {
        Q_D(QWinEventNotifier);
        QAbstractEventDispatcher *eventDispatcher = d->threadData->eventDispatcher.load();
        if (Q_UNLIKELY(!eventDispatcher)) {
            qWarning("QWinEventNotifier: Can only be used with threads started with QThread");
            return;
        }
        eventDispatcher->registerEventNotifier(this);
        d->enabled = true;
    }

    接下来到了:  eventDispatcher->registerEventNotifier(this);

    bool QEventDispatcherWin32::registerEventNotifier(QWinEventNotifier *notifier)
    {
        if (!notifier) {
            qWarning("QWinEventNotifier: Internal error");
            return false;
        } else if (notifier->thread() != thread() || thread() != QThread::currentThread()) {
            qWarning("QWinEventNotifier: event notifiers cannot be enabled from another thread");
            return false;
        }
    
        Q_D(QEventDispatcherWin32);
    
        if (d->winEventNotifierList.contains(notifier))
            return true;
    
        if (d->winEventNotifierList.count() >= MAXIMUM_WAIT_OBJECTS - 2) {
            qWarning("QWinEventNotifier: Cannot have more than %d enabled at one time", MAXIMUM_WAIT_OBJECTS - 2);
            return false;
        }
        d->winEventNotifierList.append(notifier);//加入到列表中QList
        return true;
    }

    消息循环:

     进入到

    bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)
    {
        Q_D(QEventDispatcherWin32);
    
        if (!d->internalHwnd) {
            createInternalHwnd();
            wakeUp(); // trigger a call to sendPostedEvents()
        }
    
    ......
        do {
    ......
                    haveMessage = PeekMessage(&msg, 0, 0, 0, PM_REMOVE);
    ......
    
                    if (!filterNativeEvent(QByteArrayLiteral("windows_generic_MSG"), &msg, 0)) {
                        TranslateMessage(&msg);
                        DispatchMessage(&msg);
                    }
    
    
    ......
                DWORD nCount = d->winEventNotifierList.count();//事件通知者列表
                Q_ASSERT(nCount < MAXIMUM_WAIT_OBJECTS - 1);
                for (int i=0; i<(int)nCount; i++)
                    pHandles[i] = d->winEventNotifierList.at(i)->handle();
    
                emit aboutToBlock();
                waitRet = MsgWaitForMultipleObjectsEx(nCount, pHandles, INFINITE, QS_ALLINPUT, MWMO_ALERTABLE | MWMO_INPUTAVAILABLE);//监听handle是否发生变化
                emit awake();
                if (waitRet - WAIT_OBJECT_0 < nCount) {
                    d->activateEventNotifier(d->winEventNotifierList.at(waitRet - WAIT_OBJECT_0));//激活对应的事件通知者
                    retVal = true;
                }
            }
        } while (canWait);
    
    ......
    
        return retVal;
    }
    

    当监听到QProcess创建的进程句柄不存在时,

    activateEventNotifier被调用:发送了一个QEvent::WinEventAct,sendEvent直接发送到到对方

    void QEventDispatcherWin32Private::activateEventNotifier(QWinEventNotifier * wen)
    {
        QEvent event(QEvent::WinEventAct);
        QCoreApplication::sendEvent(wen, &event);
    }
    

    中间经过:

     最终进入,之前创建的QWinEventNotifier::event中

    bool QWinEventNotifier::event(QEvent * e)
    {
        Q_D(QWinEventNotifier);
        if (e->type() == QEvent::ThreadChange) {
            if (d->enabled) {
                QMetaObject::invokeMethod(this, "setEnabled", Qt::QueuedConnection,
                                          Q_ARG(bool, true));
                setEnabled(false);
            }
        }
        QObject::event(e);                        // will activate filters
        if (e->type() == QEvent::WinEventAct) {
            emit activated(d->handleToEvent, QPrivateSignal());
            return true;
        }
        return false;
    }

    当收到 QWinEventNotifier收到QEvent::WinEventAct,则发送 emit activated(d->handleToEvent, QPrivateSignal());记得在QProess 中start中,连接了一个信号

        if (threadData->hasEventDispatcher()) {
            processFinishedNotifier = new QWinEventNotifier(pid->hProcess, q);
            QObject::connect(processFinishedNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_processDied()));
            processFinishedNotifier->setEnabled(true);
        }

    其中,q即QProcess,这段代码在void QProcessPrivate::startProcess()中;

    因此最终槽bool QProcessPrivate::_q_processDied()被调用;

    bool QProcessPrivate::_q_processDied()
    {
        Q_Q(QProcess);
    #if defined QPROCESS_DEBUG
        qDebug("QProcessPrivate::_q_processDied()");
    #endif
    #ifdef Q_OS_UNIX
        if (!waitForDeadChild())
            return false;
    #endif
    #ifdef Q_OS_WIN
        if (processFinishedNotifier)
            processFinishedNotifier->setEnabled(false);
        drainOutputPipes();
    #endif
    
        // the process may have died before it got a chance to report that it was
        // either running or stopped, so we will call _q_startupNotification() and
        // give it a chance to emit started() or errorOccurred(FailedToStart).
        if (processState == QProcess::Starting) {
            if (!_q_startupNotification())
                return true;
        }
    
        if (dying) {
            // at this point we know the process is dead. prevent
            // reentering this slot recursively by calling waitForFinished()
            // or opening a dialog inside slots connected to the readyRead
            // signals emitted below.
            return true;
        }
        dying = true;
    
        // in case there is data in the pipe line and this slot by chance
        // got called before the read notifications, call these two slots
        // so the data is made available before the process dies.
        _q_canReadStandardOutput();
        _q_canReadStandardError();
    
        findExitCode();
    
        if (crashed) {
            exitStatus = QProcess::CrashExit;
            setErrorAndEmit(QProcess::Crashed);
        }
    
        bool wasRunning = (processState == QProcess::Running);
    
        cleanup();
    
        if (wasRunning) {
            // we received EOF now:
            emit q->readChannelFinished();
            // in the future:
            //emit q->standardOutputClosed();
            //emit q->standardErrorClosed();
    
            emit q->finished(exitCode);//
            emit q->finished(exitCode, exitStatus);
        }
    #if defined QPROCESS_DEBUG
        qDebug("QProcessPrivate::_q_processDied() process is dead");
    #endif
        return true;
    }
    

    这段代码会调用:

    void QProcessPrivate::findExitCode()
    {
        DWORD theExitCode;
        Q_ASSERT(pid);
        if (GetExitCodeProcess(pid->hProcess, &theExitCode)) {
            exitCode = theExitCode;
            crashed = (exitCode == 0xf291   // our magic number, see killProcess
                       || (theExitCode >= 0x80000000 && theExitCode < 0xD0000000));
        

    获取创建进程 的退出状态,然后根据退出状态的不同发送各种信号;

    监听QPricess::finished信号依赖于qt的消息循环,如果没有启动qt的消息循环,则无法进行ProcessEvent监听句柄变化的消息

    展开全文
  • Qprocess实例

    2020-10-01 10:53:37
    演示QProcess的使用方法,在QT中直接打开word文档,并且考虑了指令中含有汉字的处理,和含有空格的处理。并考虑了内存释放
  • QProcess使用

    千次阅读 2018-10-13 17:33:07
    QProcess使用 QProcess可以用于启动外部程序,具有两种方式。 一体式:QProcess::start 方法。 外部程序启动后,将随主程序的退出而退出。 貌似要使用QProcess的close方法才可以关闭启动的外部程序。 分离式:...

    QProcess使用

    QProcess可以用于启动外部程序,具有两种方式。

    1. 一体式:QProcess::start 方法。

      外部程序启动后,将随主程序的退出而退出。 貌似要使用QProcess的close方法才可以关闭启动的外部程序。

    2. 分离式:QProcess::startDetached 方法。

      外部程序启动后,当主程序退出时并不退出,而是继续运行。

    ##1、start使用

    Qt头文件:#include <QProcess>
    void start(const QString &program, const QStringList &arguments, OpenMode mode = ReadWrite);
    1、program:启动外部应用程序的路径。不包含空格,包含空格需要在arguments中传入
    2、arguments:传入待启动外部程序的参数,即:int main(int argc, char *argv[])这里的参数。
    

    除了使用start 方法之外还可以使用:

    1、设置启动外部应用程序的路径
    QString program() const;
    void setProgram(const QString &program);
    
    2、传入待启动外部程序的参数,即:int main(int argc, char *argv[])这里的参数。
    QStringList arguments() const;
    void setArguments(const QStringList & arguments);
    
    3、使用start或者open打开外部程序
    void start(OpenMode mode = ReadWrite);
    bool open(OpenMode mode = ReadWrite) Q_DECL_OVERRIDE;
    

    使用start后,主程序退出时,外部程序不会关闭是的解决方法:

    使用void close() Q_DECL_OVERRIDE;在主程序退出的时候调用close即可结束启动的外部进程。

    展开全文
  • QProcess用法

    千次阅读 2019-04-17 10:06:58
    QProcess用法
                    QProcess类用于启动外部程序并与之通信。
    启动一个新进程的方式:把待启动的程序名称和启动参数传递给start()函数即可。
    例如:
    QProcess *parent;
    QString program = “tar”;
    QStringList arguments;
    arguments << "czvf" << "backup.tar.gz" << "/home";
    QProcess *myProcess = new QProcess(parent);
    QProcess->start(program,arguments);
    当调用start()函数后,myProcess进程立即进入启动状态,但tar程序尚未被调用,不能读写标准输入输出设备,当进程完成启动后就进入“运行状态”并向外发出started()信号。在输入输出方面,QProcess将一个进程看做一个流类型的I/O设备,可以像使用QTcpSocket读写流类型的网络连接一样来读写一个进程,可以通过QIODevice::write()函数向后所启动的标准输入写数据,也可以通过QIODevice::resd().QIODevice::readLine()和QIODevice::getChar()从这个进程的标准输出读数据。此外由于QProcess是从QIODevice类继承而来的,所以它也可以作为QXmlReader的数据在源,或者为QFtp产生上传数据。最后,当进程退出时QProcess进入起始状态--“非运行状态”,并发出finish()信号。
    void finished(int exitCode, QProcess::ExitStatus exitStatus)先好在进程中返回了进程退出的退出码和退出状态,可以调取exitCode()函数和exitStatus()函数分别获取最后退出进程的这两个值。其中“退出状态”只有正常退出和进程崩溃两种,分别对应值QProcess::NormalExit(值0)和Qprocess::CrashExit(值1)。当进程在运行中产生错误时,QProcess将发出error()信号,可以通过,调用error()函数返回最后一次产生错误的类型,并通过state()找出此时进程所处的状态。Qt定义了如下的错误类型代码:
    错误常量                        值      描述
    QProcess::FailedToStart        0       进程启动失败
    QProcess::Crashed              1       进程成功启动后崩溃
    QProcess::Timedout             2       最后一次调用waitFor...()函数超时.此时QProcess状态不变,并可以再次调用waitFor()类型的函数
    QProcess::WriteError           3       向进程写入时出错.如进程尚未启动,或者输入通道被关闭时
    QProcess::ReadError            4       从进程中读取数据时出错.如进程尚未启动时
    QProcess::UnknownError         5       未知错误.这也是error()函数返回的默认值
    进程的标准输出
    stdout:通常用于控制台下输出
    stderr:通常用于进程打印错误
    它们本质上是两个独立的数据流.
    可以通过调用setReadChanned()函数设置当前的读通道
    当有可读数据时Qt将发发出readyRead()信号
    如果是标准输出和标准错误通道中读取数据,还会发出readyReadStandardOutput()信号
    如果是标准错误也会发出readyReadStandardError()信号
    readAllStandardOutput()函数从标准输出通道中读取数据
    readAllStandardErrot()函数从标准错误通道中读取数据
    在进程启动以前以MergedChannels参数调用setReadChannelMode()函数可以把标准输出通道和标准输错误通道合并
    例:
    #include <QApplication>
    #include <QProcess>
    #include <QString>
    #include <iostream>
    int main (int argc, char *argv[])
    {
        QApplication app(argc, argv);
        QProcess proc;
        QStringList arguments;
        arguments << "-na";
        proc.start("netstat", arguments);

        // 等待进程启动
        if (!proc.waitForStarted())
        {
            std::cout << "启动失败\n";
            return false;
        }
        // 关闭写通道,因为没有向进程写数据,没用到 
        proc.closeWriteChannel();

        // 用于保存进程的控制台输出
        QByteArray procOutput;
        // 等待进程结束
        while (false == proc.waitForFinished())
        {
            ;
        }
        // 读取进程输出到控制台的数据
        procOutput = proc.readAll();
        // 输出读到的数据
        std::cout << procOutput.data() << std::endl;
        // 返回
        return EXIT_SUCCESS;
    }
               
    展开全文
  • QProcess启动

    2019-10-18 22:36:20
    QProcess可以启动外部exe程序、执行bat批处理脚本、执行cmd命令等 启动方式有两种: 一体式 外部程序启动后,将随主程序的退出而退出。 void QProcess::start(const QString &program, const QStringList &...

    QProcess可以启动外部exe程序、执行bat批处理脚本、执行cmd命令等

    启动方式有两种:

    • 一体式

    外部程序启动后,将随主程序的退出而退出。

    void QProcess::start(const QString &program, const QStringList &arguments, OpenMode mode = ReadWrite)

     例:

    QProcess process;
    process.start("C:\\Windows\\System32\cmd.exe");
    // same as process.start("C:\\Windows\\System32\cmd.exe", QStringList());
      ...
    • 分离式

    外部程序启动后,当主程序退出时并不退出,而是继续运行。

    void QProcess::startDetached(const QString & program, const QStringList & arguments, const QString & workingDirectory = QString(), qint64 * pid = 0)

    例:

    QProcess process;
    process.startDetached("C:\\Windows\\System32\cmd.exe");
    // same as process.startDetached("C:\\Windows\\System32\cmd.exe", QStringList());
      ...

     

    展开全文
  • QProcess

    2019-10-06 08:57:28
    想要使用Qt的QProcess类启动一个程序,如IE,于是尝试使用如下程序: QProcess *qp = new QProcess(); qp->start("C:\\Program Files\\Internet Explorer\\iexplore.exe"); 结果无法启动IE程序。 Note:...
  • QProcess应用

    2020-02-17 21:21:33
    利用QProcess调用外部程序,并传递参数 //typedef QProcess::CreateProcessArgumentModifier //Note: This typedef is only available on desktop Windows. include <Windows.h> QString program = "C:/...
  • QProcess time out

    2019-07-18 00:02:14
    QProcess详解QProcessbool QProcess::waitForStarted(int msecs = 30000)time out 错误分析QProcess time out错误解决 QProcess bool QProcess::waitForStarted(int msecs = 30000) time out 错误分析 默认情况下,...
  • QProcess文档

    2020-09-14 21:17:35
    QProcess类用于启动外部程序并与它们通信。 要启动进程,请将要运行的程序的名称和命令行参数作为参数传递给start()。在字符串中以字符串形式提供。 或者,可以将程序设置为使用setProgram()和setArguments()...
  • QProcess 使用

    2020-03-26 12:31:15
    一,QProcess 启动方式 (1),execute execute是阻塞调用, 并且继承了调用者环境变量和工作目录。并且无法与其交互,因为阻塞了。 (2),start start则是异步调用,而非阻塞调用。 可以和外部程序进行交互。 (3),...
  • QProcess资料大全

    2014-04-05 19:35:03
    QT 中QProcess模块的较全面资料,适合于编程查询和学习
  • qt QProcess

    千次阅读 2018-03-15 00:22:49
    qt QProcessQProcess常用三个函数:QProcess::execute():以阻塞方式打开外部程序,只有当外部程序执行完后才继续往后执行现程序。其中,外部程序的标准输出、标准错误都是重定向到现程序的标准输出和标准错误。...
  • QT 随笔 QProcess中waitForFinished的坑

    万次阅读 2020-11-02 09:24:05
    文章为个人创作,如转载请标注。 当我们执行一个超过30s的动作的时候,int msecs = 30000,...QProcess p; p.start(sCommandLine); p.waitForStarted(); p.waitForFinished(); //此处其实是有一个缺省参数的,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,458
精华内容 1,783
关键字:

qprocess