Класс QProcess

Класс QProcess используется для запуска внешних программ и для связи с ними. Подробнее...

• Список всех членов, включая унаследованные члены
• Устаревшие члены

Примечание: Все функции в этом классе являются реентерабельными.

Открытые типы

Открытые функции

Переопределенные открытые функции

Public Slots

Signals

Static Public Members

Protected Functions

Reimplemented Protected Functions

Detailed Description

Running a Process

To start a process, pass the name and command line arguments of the program you want to run as arguments to start(). Arguments are supplied as individual strings in a QStringList.

Alternatively, you can set the program to run with setProgram() and setArguments(), and then call start() or open().

For example, the following code snippet runs the analog clock example in the Fusion style on X11 platforms by passing strings containing "-style" and "fusion" as two items in the list of arguments:

    QObject *parent;
    ...
    QString program = "./path/to/Qt/examples/widgets/analogclock";
    QStringList arguments;
    arguments << "-style" << "fusion";

    QProcess *myProcess = new QProcess(parent);
    myProcess->start(program, arguments);

QProcess then enters the Starting state, and when the program has started, QProcess enters the Running state and emits started().

QProcess allows you to treat a process as a sequential I/O device. You can write to and read from the process just as you would access a network connection using QTcpSocket. You can then write to the process's standard input by calling write(), and read the standard output by calling read(), readLine(), and getChar(). Because it inherits QIODevice, QProcess can also be used as an input source for QXmlReader, or for generating data to be uploaded using QNetworkAccessManager.

When the process exits, QProcess reenters the NotRunning state (the initial state), and emits finished().

The finished() signal provides the exit code and exit status of the process as arguments, and you can also call exitCode() to obtain the exit code of the last process that finished, and exitStatus() to obtain its exit status. If an error occurs at any point in time, QProcess will emit the errorOccurred() signal. You can also call error() to find the type of error that occurred last, and state() to find the current process state.

Communicating via Channels

Processes have two predefined output channels: The standard output channel (stdout) supplies regular console output, and the standard error channel (stderr) usually supplies the errors that are printed by the process. These channels represent two separate streams of data. You can toggle between them by calling setReadChannel(). QProcess emits readyRead() when data is available on the current read channel. It also emits readyReadStandardOutput() when new standard output data is available, and when new standard error data is available, readyReadStandardError() is emitted. Instead of calling read(), readLine(), or getChar(), you can explicitly read all data from either of the two channels by calling readAllStandardOutput() or readAllStandardError().

The terminology for the channels can be misleading. Be aware that the process's output channels correspond to QProcess's read channels, whereas the process's input channels correspond to QProcess's write channels. This is because what we read using QProcess is the process's output, and what we write becomes the process's input.

QProcess can merge the two output channels, so that standard output and standard error data from the running process both use the standard output channel. Call setProcessChannelMode() with MergedChannels before starting the process to activate this feature. You also have the option of forwarding the output of the running process to the calling, main process, by passing ForwardedChannels as the argument. It is also possible to forward only one of the output channels - typically one would use ForwardedErrorChannel, but ForwardedOutputChannel also exists. Note that using channel forwarding is typically a bad idea in GUI applications - you should present errors graphically instead.

Certain processes need special environment settings in order to operate. You can set environment variables for your process by calling setProcessEnvironment(). To set a working directory, call setWorkingDirectory(). By default, processes are run in the current working directory of the calling process.

The positioning and the screen Z-order of windows belonging to GUI applications started with QProcess are controlled by the underlying windowing system. For Qt 5 applications, the positioning can be specified using the -qwindowgeometry command line option; X11 applications generally accept a -geometry command line option.

Synchronous Process API

QProcess provides a set of functions which allow it to be used without an event loop, by suspending the calling thread until certain signals are emitted:

• waitForStarted() blocks until the process has started.
• waitForReadyRead() blocks until new data is available for reading on the current read channel.
• waitForBytesWritten() blocks until one payload of data has been written to the process.
• waitForFinished() blocks until the process has finished.

Вызов этих функций из основного потока (потока, вызывающего QApplication::exec()) может привести к зависанию пользовательского интерфейса.

Следующий пример демонстрирует сжатие строки "Qt rocks!", без цикла обработки событий:

    QProcess gzip;
    gzip.start("gzip", QStringList() << "-c");
    if (!gzip.waitForStarted())
        return false;

    gzip.write("Qt rocks!");
    gzip.closeWriteChannel();

    if (!gzip.waitForFinished())
        return false;

    QByteArray result = gzip.readAll();

Примечания для пользователей Windows

Некоторые команды Windows (например, dir) не предоставляются отдельными приложениями, а самим интерпретатором команд. Если вы попытаетесь использовать QProcess для прямого выполнения этих команд, это не сработает. Одним из возможных решений является запуск самого интерпретатора команд (cmd.exe на некоторых системах Windows) и просьба интерпретатору выполнить нужную команду.

См. также QBuffer, QFile и QTcpSocket.

Документация по типам членов

QProcess::CreateProcessArgumentModifier

В Windows, QProcess использует функцию Win32 API CreateProcess для запуска дочерних процессов. Хотя QProcess предоставляет удобный способ запуска процессов без забот о деталях платформы, в некоторых случаях желательно настроить параметры, передаваемые в CreateProcess. Это делается путем определения функции CreateProcessArgumentModifier и передачи её в setCreateProcessArgumentsModifier.

Функция CreateProcessArgumentModifier принимает один параметр: указатель на структуру CreateProcessArguments. Члены этой структуры будут переданы в CreateProcess после вызова функции CreateProcessArgumentModifier.

Следующий пример демонстрирует, как передавать пользовательские флаги в CreateProcess. При запуске консольного процесса B из консольного процесса A, QProcess по умолчанию использует окно консоли процесса A для процесса B. В данном примере для дочернего процесса B создается новое окно консоли с пользовательской цветовой схемой.

    QProcess process;
    process.setCreateProcessArgumentsModifier([] (QProcess::CreateProcessArguments *args)
    {
        args->flags |= CREATE_NEW_CONSOLE;
        args->startupInfo->dwFlags &= ~STARTF_USESTDHANDLES;
        args->startupInfo->dwFlags |= STARTF_USEFILLATTRIBUTE;
        args->startupInfo->dwFillAttribute = BACKGROUND_BLUE | FOREGROUND_RED
                                           | FOREGROUND_INTENSITY;
    });
    process.start("C:\\Windows\\System32\\cmd.exe", QStringList() << "/k" << "title" << "The Child Process");

См. также QProcess::CreateProcessArguments и setCreateProcessArgumentsModifier().

перечисление QProcess::ExitStatus

Это перечисление описывает различные статусы завершения QProcess.

См. также exitStatus().

[since 5.2] перечисление QProcess::InputChannelMode

Это перечисление описывает режимы канала ввода процесса QProcess. Передайте одно из этих значений в setInputChannelMode() для установки текущего режима канала записи.

Это перечисление было введено или изменено в Qt 5.2.

См. также setInputChannelMode().

перечисление QProcess::ProcessChannel

Это перечисление описывает каналы процесса, используемые работающим процессом. Передайте одно из этих значений в setReadChannel() для установки текущего канала чтения QProcess.

См. также setReadChannel().

перечисление QProcess::ProcessChannelMode

Это перечисление описывает режимы канала вывода процесса QProcess. Передайте одно из этих значений в setProcessChannelMode() для установки текущего режима канала чтения.

См. также setProcessChannelMode().

перечисление QProcess::ProcessError

Это перечисление описывает различные типы ошибок, которые сообщаются QProcess.

См. также error().

перечисление QProcess::ProcessState

Это перечисление описывает различные состояния QProcess.

См. также state().

Документация по функциям членов

QProcess::QProcess(QObject *parent = nullptr)

Создаёт объект QProcess с заданным parent.

[signal, since 5.6] void QProcess::errorOccurred(QProcess::ProcessError error)

Этот сигнал излучается, когда в процессе возникает ошибка. Указанное error описывает тип возникшей ошибки.

Эта функция была добавлена в Qt 5.6.

[signal] void QProcess::finished(int exitCode, QProcess::ExitStatus exitStatus = NormalExit)

Этот сигнал излучается, когда процесс завершается. exitCode — код завершения процесса (действителен только для нормального завершения), а exitStatus — состояние завершения. После завершения процесса буферы в QProcess остаются неизменными. Вы по-прежнему можете прочитать любые данные, которые процесс мог записать перед завершением.

См. также exitStatus().

[slot] void QProcess::kill()

Завершает текущий процесс, вызывая его немедленное завершение.

В Windows функция kill() использует TerminateProcess, а в Unix и macOS — сигнал SIGKILL, отправленный процессу.

См. также terminate().

[private signal] void QProcess::readyReadStandardError()

Этот сигнал излучается, когда процесс предоставил новые данные через канал стандартной ошибки (stderr). Он излучается независимо от текущего канала чтения.

Примечание: Это частный сигнал. Он может использоваться в подключениях сигналов, но не может излучаться пользователем.

См. также readAllStandardError() и readChannel().

[private signal] void QProcess::readyReadStandardOutput()

Этот сигнал излучается, когда процесс предоставил новые данные через канал стандартного вывода (stdout). Он излучается независимо от текущего канала чтения.

Примечание: Это частный сигнал. Он может использоваться в подключениях сигналов, но не может излучаться пользователем.

См. также readAllStandardOutput() и readChannel().

[private signal] void QProcess::started()

Этот сигнал излучается объектом QProcess, когда процесс запущен и state() возвращает Running.

Примечание: Это частный сигнал. Он может использоваться в подключениях сигналов, но не может излучаться пользователем.

[private signal] void QProcess::stateChanged(QProcess::ProcessState newState)

Этот сигнал излучается всякий раз, когда состояние QProcess изменяется. Аргумент newState — состояние, в которое перешёл QProcess.

Примечание: Это частный сигнал. Он может использоваться в подключениях сигналов, но не может излучаться пользователем.

[slot] void QProcess::terminate()

Попытка завершить процесс.

Процесс может не завершиться в результате вызова этой функции (ему предоставляется возможность запросить у пользователя сохранение несохранённых файлов и т. д.).

В Windows функция terminate() посылает сообщение WM_CLOSE всем верхним окнам процесса, а затем главному потоку самого процесса. В Unix и macOS отправляется сигнал SIGTERM.

Консольные приложения в Windows, которые не запускают цикл событий или цикл событий которых не обрабатывает сообщение WM_CLOSE, могут быть завершены только путём вызова kill().

См. также kill().

[virtual] QProcess::~QProcess()

Удаляет объект QProcess, т. е. завершает процесс.

Обратите внимание, что эта функция не вернётся, пока процесс не будет завершён.

[since 5.0] QStringList QProcess::arguments() const

Возвращает аргументы командной строки, с которыми процесс был последний раз запущен.

Эта функция была добавлена в Qt 5.0.

См. также setArguments() и start().

[override virtual] qint64 QProcess::bytesToWrite() const

Переопределяет: QIODevice::bytesToWrite() const.

[since 6.0] std::function<void ()> QProcess::childProcessModifier() const

Возвращает функцию-модификатор, ранее установленную при вызове setChildProcessModifier().

Эта функция была добавлена в Qt 6.0.

См. также setChildProcessModifier().

[override virtual] void QProcess::close()

Переопределяет: QIODevice::close().

Закрывает все каналы связи с процессом и завершает его. После вызова этой функции QProcess больше не будет излучать readyRead(), и данные больше нельзя читать или записывать.

void QProcess::closeReadChannel(QProcess::ProcessChannel channel)

Закрывает канал чтения channel. После вызова этой функции QProcess больше не будет получать данные по каналу. Любые данные, которые уже были получены, всё ещё доступны для чтения.

Вызовите эту функцию для экономии памяти, если вас не интересует вывод процесса.

См. также closeWriteChannel() и setReadChannel().

void QProcess::closeWriteChannel()

Планирует закрытие канала записи QProcess. Канал закроется после записи всех данных в процесс. После вызова этой функции любые попытки записи в процесс завершатся ошибкой.

Закрытие канала записи необходимо для программ, которые считывают входные данные до закрытия канала. Например, программа «more» используется для отображения текстовых данных в консоли как в Unix, так и в Windows. Но она не будет отображать текстовые данные, пока канал записи QProcess не будет закрыт. Пример:

QProcess more;
more.start("more");
more.write("Text to display");
more.closeWriteChannel();
// QProcess will emit readyRead() once "more" starts printing

Канал записи неявно открывается при вызове start().

См. также closeReadChannel().

[since 5.7] QProcess::CreateProcessArgumentModifier QProcess::createProcessArgumentsModifier() const

Возвращает ранее установленную функцию-модификатор CreateProcess.

Эта функция была добавлена в Qt 5.7.

См. также setCreateProcessArgumentsModifier() и QProcess::CreateProcessArgumentModifier.

QProcess::ProcessError QProcess::error() const

Возвращает тип последней возникшей ошибки.

См. также state().

[static] int QProcess::execute(const QString &program, const QStringList &arguments = {})

Запускает программу program с аргументами arguments в новом процессе, ожидает его завершения и возвращает код завершения процесса. Любые данные, которые новый процесс записывает в консоль, передаются вызывающему процессу.

Окружение и рабочая директория наследуются от вызывающего процесса.

Обработка аргументов идентична соответствующему перегрузке start().

Если процесс нельзя запустить, возвращается -2. Если процесс аварийно завершается, возвращается -1. В противном случае возвращается код завершения процесса.

См. также start().

int QProcess::exitCode() const

Возвращает код завершения последнего завершённого процесса.

Это значение недействительно, если exitStatus() не возвращает NormalExit.

QProcess::ExitStatus QProcess::exitStatus() const

Возвращает состояние завершения последнего завершённого процесса.

В Windows, если процесс был завершён с помощью TerminateProcess() из другого приложения, эта функция всё равно вернёт NormalExit, если только код выхода не меньше 0.

[since 5.2] QProcess::InputChannelMode QProcess::inputChannelMode() const

Возвращает режим канала стандартного ввода QProcess.

Эта функция была добавлена в Qt 5.2.

См. также setInputChannelMode() и InputChannelMode.

[override virtual] bool QProcess::isSequential() const

Переопределяет: QIODevice::isSequential() const.

QString QProcess::nativeArguments() const

Возвращает дополнительные системные аргументы командной строки для программы.

См. также setNativeArguments().

[static, since 5.2] QString QProcess::nullDevice()

Пустой файл устройства операционной системы.

Возвращаемый путь к файлу использует системные разделители каталогов.

Функция была добавлена в Qt 5.2.

См. также QProcess::setStandardInputFile(), QProcess::setStandardOutputFile(), и QProcess::setStandardErrorFile().

[override virtual] bool QProcess::open(QIODeviceBase::OpenMode mode = ReadWrite)

Переопределяет: QIODevice::open(QIODeviceBase::OpenMode mode).

Запускает программу, заданную функцией setProgram(), с аргументами, заданными функцией setArguments(). Режим открытия устанавливается в mode.

Этот метод является псевдонимом для start() и существует только для полной реализации интерфейса, определенного классом QIODevice.

Возвращает true, если программа была запущена.

См. также start(), setProgram(), и setArguments().

QProcess::ProcessChannelMode QProcess::processChannelMode() const

Возвращает режим канала стандартного вывода и стандартной ошибки процесса QProcess.

См. также setProcessChannelMode(), ProcessChannelMode и setReadChannel().

QProcessEnvironment QProcess::processEnvironment() const

Возвращает среду, которую QProcess передаст своему дочернему процессу, или пустой объект, если среда не была установлена с помощью setEnvironment() или setProcessEnvironment(). Если среда не была установлена, используется среда вызывающего процесса.

См. также setProcessEnvironment(), setEnvironment(), и QProcessEnvironment::isEmpty().

[since 5.3] qint64 QProcess::processId() const

Возвращает системный идентификатор процесса, если доступен. Если процесс не запущен, возвращается 0.

Функция была добавлена в Qt 5.3.

[since 5.0] QString QProcess::program() const

Возвращает программу, с которой процесс был последний раз запущен.

Функция была добавлена в Qt 5.0.

См. также setProgram() и start().

QByteArray QProcess::readAllStandardError()

Независимо от текущего канала чтения, эта функция возвращает все данные, доступные из стандартного потока ошибок процесса, как QByteArray.

См. также readyReadStandardError(), readAllStandardOutput(), readChannel(), и setReadChannel().

QByteArray QProcess::readAllStandardOutput()

Независимо от текущего канала чтения, эта функция возвращает все доступные данные из стандартного потока вывода процесса в виде QByteArray.

См. также readyReadStandardOutput(), readAllStandardError(), readChannel(), и setReadChannel().

QProcess::ProcessChannel QProcess::readChannel() const

Возвращает текущий канал чтения процесса QProcess.

См. также setReadChannel().

[override virtual protected] qint64 QProcess::readData(char *data, qint64 maxlen)

Переопределяет: QIODevice::readData(char *data, qint64 maxSize).

[since 5.1] void QProcess::setArguments(const QStringList &arguments)

Устанавливает arguments для передачи вызываемой программе при запуске процесса. Эта функция должна быть вызвана перед start().

Функция была добавлена в Qt 5.1.

См. также start(), setProgram(), и arguments().

[since 6.0] void QProcess::setChildProcessModifier(const std::function<void ()> &modifier)

Устанавливает функцию modifier для дочернего процесса для систем Unix (включая macOS; для Windows, см. setCreateProcessArgumentsModifier()). Функция, содержащаяся в аргументе modifier, будет вызвана в дочернем процессе после завершения fork() и установки QProcess стандартных файловых дескрипторов для дочернего процесса, но перед execve(), внутри start(). Модификатор полезен для изменения определенных свойств дочернего процесса, таких как настройка дополнительных файловых дескрипторов или закрытие других, изменение уровня приоритета, отключение от управляющего TTY и т. д.

Следующий пример показывает настройку дочернего процесса для запуска без привилегий:

void runSandboxed(const QString &name, const QStringList &arguments)
{
    QProcess proc;
    proc.setChildProcessModifier([] {
        // Drop all privileges in the child process, and enter
        // a chroot jail.
        ::setgroups(0, nullptr);
        ::chroot("/run/safedir");
        ::chdir("/");
        ::setgid(safeGid);
        ::setuid(safeUid);
        ::umask(077);
    });
    proc.start(name, arguments);
    proc.waitForFinished();
}

Если функция модификатора должна завершить процесс, используйте _exit(), а не exit().

Функция была добавлена в Qt 6.0.

См. также childProcessModifier().

[since 5.7] void QProcess::setCreateProcessArgumentsModifier(QProcess::CreateProcessArgumentModifier modifier)

Устанавливает modifier для вызова API Win32 CreateProcess. Передайте QProcess::CreateProcessArgumentModifier(), чтобы удалить ранее установленный.

Функция была добавлена в Qt 5.7.

См. также createProcessArgumentsModifier(), QProcess::CreateProcessArgumentModifier, и setChildProcessModifier().

[since 5.2] void QProcess::setInputChannelMode(QProcess::InputChannelMode mode)

Устанавливает режим канала стандартного ввода процесса QProcess в указанный mode. Этот режим будет использован при следующем вызове start().

Функция была добавлена в Qt 5.2.

См. также inputChannelMode() и InputChannelMode.

void QProcess::setNativeArguments(const QString &arguments)

Это перегруженная функция.

Устанавливает дополнительные системные аргументы командной строки arguments для программы.

В операционных системах, где системный API для передачи аргументов командной строки дочернему процессу в формате, использует строку, можно представить командные строки, которые нельзя передать через основанный на списке API QProcess. В таких случаях эта функция должна использоваться для установки строки, которая добавляется к строке, составленной из обычного списка аргументов, с разделителем пробелом.

См. также nativeArguments().

void QProcess::setProcessChannelMode(QProcess::ProcessChannelMode mode)

Устанавливает режим канала стандартного вывода и стандартной ошибки процесса QProcess в указанный mode. Этот режим будет использован при следующем вызове start(). Например:

QProcess builder;
builder.setProcessChannelMode(QProcess::MergedChannels);
builder.start("make", QStringList() << "-j2");

if (!builder.waitForFinished())
    qDebug() << "Make failed:" << builder.errorString();
else
    qDebug() << "Make output:" << builder.readAll();

См. также processChannelMode(), ProcessChannelMode, и setReadChannel().

void QProcess::setProcessEnvironment(const QProcessEnvironment &environment)

Устанавливает среду, которую QProcess передаст дочернему процессу.

Например, следующий код добавляет переменную среды TMPDIR:

QProcess process;
QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
env.insert("TMPDIR", "C:\\MyApp\\temp"); // Add an environment variable
process.setProcessEnvironment(env);
process.start("myapp");

Обратите внимание, что в Windows имена переменных среды нечувствительны к регистру.

См. также processEnvironment(), QProcessEnvironment::systemEnvironment() и setEnvironment().

[protected] void QProcess::setProcessState(QProcess::ProcessState state)

Устанавливает текущее состояние QProcess в указанное state.

См. также state().

[since 5.1] void QProcess::setProgram(const QString &program)

Устанавливает program для использования при запуске процесса. Эта функция должна быть вызвана до start().

Эта функция была добавлена в Qt 5.1.

См. также start(), setArguments() и program().

void QProcess::setReadChannel(QProcess::ProcessChannel channel)

Устанавливает текущий канал чтения QProcess в указанный channel. Текущий входной канал используется функциями read(), readAll(), readLine() и getChar(). Он также определяет, какой канал вызывает у QProcess излучение сигнала readyRead().

См. также readChannel().

void QProcess::setStandardErrorFile(const QString &fileName, QIODeviceBase::OpenMode mode = Truncate)

Перенаправляет стандартный поток ошибок процесса в файл fileName. При включенном перенаправлении канал чтения стандартного потока ошибок закрывается: чтение из него с помощью read() всегда завершится неудачей, как и readAllStandardError(). Файл будет добавлен в конец, если mode равен Append, в противном случае он будет обнулен.

См. setStandardOutputFile() для получения дополнительной информации о том, как открывается файл.

Примечание: если setProcessChannelMode() вызывалось с аргументом QProcess::MergedChannels, эта функция не оказывает никакого влияния.

См. также setStandardInputFile(), setStandardOutputFile() и setStandardOutputProcess().

void QProcess::setStandardInputFile(const QString &fileName)

Перенаправляет стандартный ввод процесса в файл, указанный fileName. При включенном перенаправлении ввода объект QProcess будет находиться в режиме только для чтения (вызов write() приведет к ошибке).

Чтобы процесс сразу же прочитал конец файла, передайте nullDevice() сюда. Это чище, чем использование closeWriteChannel() перед записью любых данных, так как это может быть установлено до запуска процесса.

Если файла fileName не существует в момент вызова start() или он недоступен для чтения, запуск процесса завершится ошибкой.

Вызов setStandardInputFile() после запуска процесса не имеет эффекта.

См. также setStandardOutputFile(), setStandardErrorFile() и setStandardOutputProcess().

void QProcess::setStandardOutputFile(const QString &fileName, QIODeviceBase::OpenMode mode = Truncate)

Перенаправляет стандартный вывод процесса в файл fileName. При включенном перенаправлении канал чтения стандартного вывода закрывается: чтение из него с помощью read() всегда завершится неудачей, как и readAllStandardOutput().

Чтобы отбросить весь стандартный вывод процесса, передайте nullDevice() сюда. Это более эффективно, чем просто никогда не читать стандартный вывод, так как буферы QProcess не заполняются.

Если файла fileName не существует в момент вызова start(), он будет создан. Если его нельзя создать, запуск завершится ошибкой.

Если файл существует и mode равен QIODevice::Truncate, файл будет обнулен. В противном случае (если mode равен QIODevice::Append), файл будет добавлен в конец.

Вызов setStandardOutputFile() после запуска процесса не имеет эффекта.

См. также setStandardInputFile(), setStandardErrorFile() и setStandardOutputProcess().

void QProcess::setStandardOutputProcess(QProcess *destination)

Перенаправляет поток стандартного вывода этого процесса в поток стандартного ввода процесса destination.

Следующая команда оболочки:

command1 | command2

Может быть выполнена с помощью QProcess с помощью следующего кода:

QProcess process1;
QProcess process2;

process1.setStandardOutputProcess(&process2);

process1.start("command1");
process2.start("command2");

void QProcess::setWorkingDirectory(const QString &dir)

Устанавливает рабочую директорию в dir. QProcess запустит процесс в этой директории. По умолчанию процесс запускается в рабочей директории вызывающего процесса.

См. также workingDirectory() и start().

[static, since 5.15] QStringList QProcess::splitCommand(QStringView command)

Разделяет строку command на список токенов и возвращает список.

Токены со пробелами могут быть заключены в двойные кавычки; три последовательных двойных кавычки представляют собой символ кавычки.

Эта функция была добавлена в Qt 5.15.

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

Запускает заданную program в новом процессе, передавая аргументы командной строки в arguments.

Объект QProcess сразу переходит в состояние Starting. Если процесс запущен успешно, QProcess излучит started; в противном случае, излучится errorOccurred().

Windows: Аргументы заключаются в кавычки и объединяются в строку командной строки, совместимую с функцией CommandLineToArgvW() Windows. Для программ с другими требованиями к кавычкам командной строки необходимо использовать setNativeArguments(). Одна из заметных программ, не следующая правилам CommandLineToArgvW(), — cmd.exe, а, следовательно, и все скрипты пакетных файлов.

Режим OpenMode установлен на mode.

Если объект QProcess уже выполняет процесс, в консоли может быть выведено предупреждение, и существующий процесс будет продолжать работать без изменений.

См. также processId(), started(), waitForStarted() и setNativeArguments().

[since 5.1] void QProcess::start(QIODeviceBase::OpenMode mode = ReadWrite)

Это перегруженная функция.

Запускает программу, заданную с помощью setProgram(), с аргументами, заданными с помощью setArguments(). Режим OpenMode установлен на mode.

Эта функция была добавлена в Qt 5.1.

См. также open(), setProgram() и setArguments().

[since 6.0] void QProcess::startCommand(const QString &command, QIODeviceBase::OpenMode mode = ReadWrite)

Запускает команду command в новом процессе. Режим OpenMode установлен на mode.

command — это строка текста, содержащая имя программы и ее аргументы. Аргументы разделены одним или несколькими пробелами. Например:

QProcess process;
process.startCommand("del /s *.txt");
// same as process.start("del", QStringList() << "/s" << "*.txt");
...

Аргументы, содержащие пробелы, должны быть заключены в кавычки, чтобы они правильно передавались новому процессу. Например:

QProcess process;
process.startCommand("dir \"My Documents\"");

Буквальные кавычки в строке command представлены тройными кавычками. Например:

QProcess process;
process.startCommand("dir \"Epic 12\"\"\" Singles\"");

После того, как строка command была разделена и убраны кавычки, эта функция ведет себя как start().

В операционных системах, где системный API для передачи аргументов командной строки дочернему процессу по умолчанию использует одну строку (Windows), можно представить командные строки, которые нельзя передать через основанный на списке API QProcess. В этих редких случаях вам нужно использовать setProgram() и setNativeArguments() вместо этой функции.

Эта функция была представлена в Qt 6.0.

См. также splitCommand() и start().

[since 5.10] bool QProcess::startDetached(qint64 *pid = nullptr)

Запускает программу, установленную с помощью setProgram(), с аргументами, установленными с помощью setArguments(), в новом процессе и отсоединяется от него. Возвращает true при успехе; в противном случае возвращает false. Если вызывающий процесс завершается, отделённый процесс продолжит выполняться без изменений.

Unix: Запущенный процесс будет работать в своей собственной сессии и вести себя как демон.

Процесс будет запущен в каталоге, заданном с помощью setWorkingDirectory(). Если workingDirectory() пусто, каталог работы наследуется от вызывающего процесса.

Если функция выполнена успешно, то *pid устанавливается в идентификатор процесса запущенного процесса; в противном случае, он устанавливается в -1. Обратите внимание, что дочерний процесс может завершиться, и PID может стать недействительным без уведомления. Кроме того, после завершения дочернего процесса тот же PID может быть повторно использован другим процессом. Код пользователя должен быть осторожен при использовании этой переменной, особенно если он намерен принудительно завершить процесс средствами операционной системы.

Следующие методы установки свойств поддерживаются startDetached():

• setArguments()
• setCreateProcessArgumentsModifier()
• setNativeArguments()
• setProcessEnvironment()
• setProgram()
• setStandardErrorFile()
• setStandardInputFile()
• setStandardOutputFile()
• setProcessChannelMode(QProcess::MergedChannels)
• setStandardOutputProcess()
• setWorkingDirectory()

Все остальные свойства объекта QProcess игнорируются.

Эта функция была представлена в Qt 5.10.

См. также start() и startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory, qint64 *pid).

[static] bool QProcess::startDetached(const QString &program, const QStringList &arguments = {}, const QString &workingDirectory = QString(), qint64 *pid = nullptr)

Эта функция перегружает startDetached().

Запускает программу program с аргументами arguments в новом процессе и отсоединяется от него. Возвращает true при успехе; в противном случае возвращает false. Если вызывающий процесс завершается, отделённый процесс продолжит выполняться без изменений.

Обработка аргументов идентична соответствующей перегрузке start().

Процесс будет запущен в каталоге workingDirectory. Если workingDirectory пуста, каталог работы наследуется от вызывающего процесса.

Если функция выполнена успешно, то *pid устанавливается в идентификатор процесса запущенного процесса.

См. также start().

QProcess::ProcessState QProcess::state() const

Возвращает текущее состояние процесса.

См. также stateChanged() и error().

[static] QStringList QProcess::systemEnvironment()

Возвращает среду вызывающего процесса в виде списка пар ключ=значение. Пример:

QStringList environment = QProcess::systemEnvironment();
// environment = {"PATH=/usr/bin:/usr/local/bin",
//                "USER=greg", "HOME=/home/greg"}

Эта функция не кеширует системную среду. Поэтому возможно получить обновлённую версию среды, если были вызваны функции низкого уровня C-библиотеки, такие как setenv или putenv.

Однако обратите внимание, что повторные вызовы этой функции будут создавать новый список переменных среды, что является нетривиальной операцией.

См. также QProcessEnvironment::systemEnvironment() и setProcessEnvironment().

[override virtual] bool QProcess::waitForBytesWritten(int msecs = 30000)

Реализует: QIODevice::waitForBytesWritten(int msecs).

bool QProcess::waitForFinished(int msecs = 30000)

Блокирует выполнение, пока процесс не завершится и не будет послан сигнал finished(), или пока не пройдёт msecs миллисекунд.

Возвращает true, если процесс завершился; в противном случае возвращает false (если операция истекла, произошла ошибка или этот QProcess уже завершен).

Эта функция может работать без цикла событий. Она полезна при написании приложений без графического интерфейса и при выполнении операций ввода-вывода в потоке, не связанном с графическим интерфейсом.

Если msecs равно -1, эта функция не будет ожидать таймаута.

См. также finished(), waitForStarted(), waitForReadyRead(), и waitForBytesWritten().

[override virtual] bool QProcess::waitForReadyRead(int msecs = 30000)

Реализует: QIODevice::waitForReadyRead(int msecs).

bool QProcess::waitForStarted(int msecs = 30000)

Блокирует выполнение, пока процесс не начнётся и не будет послан сигнал started(), или пока не пройдёт msecs миллисекунд.

Возвращает true, если процесс запустился успешно; в противном случае возвращает false (если операция истекла или произошла ошибка).

Эта функция может работать без цикла событий. Она полезна при написании приложений без графического интерфейса и при выполнении операций ввода-вывода в потоке, не связанном с графическим интерфейсом.

Если msecs равно -1, эта функция не будет ожидать таймаута.

См. также started(), waitForReadyRead(), waitForBytesWritten(), и waitForFinished().

QString QProcess::workingDirectory() const

Если QProcess был назначен рабочий каталог, эта функция возвращает рабочий каталог, в который QProcess войдёт перед запуском программы. В противном случае (т.е., если каталог не был назначен), возвращается пустая строка, и QProcess использует текущий рабочий каталог приложения.

См. также setWorkingDirectory().

[override virtual protected] qint64 QProcess::writeData(const char *data, qint64 len)

Реализует: QIODevice::writeData(const char *data, qint64 maxSize).