Класс QProcess

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

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

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

Типы публичного доступа

Публичные функции

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

• 44 public functions inherited from QIODevice
• 32 public functions inherited from QObject

Public Slots

• 1 public slot inherited from QObject

Сигналы

• 6 signals inherited from QIODevice
• 2 signals inherited from QObject

Статические public члены

• 11 static public members inherited from QObject

Защищенные функции

Переопределенные защищенные функции

• 5 protected functions inherited from QIODevice
• 9 protected functions inherited from QObject

Связанные non-члены

Макросы

Дополнительные унаследованные члены

• 1 property inherited from QObject

Подробное описание

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

Запуск процесса

Для запуска процесса передайте имя и аргументы командной строки программы в качестве аргументов start(). Аргументы передаются как отдельные строки в QStringList.

В качестве альтернативы можно установить программу для запуска с помощью setProgram() и setArguments(), а затем вызвать start() или open().

Например, следующий фрагмент кода запускает пример аналоговых часов в стиле Fusion на платформах X11, передавая строки, содержащие "-style" и "fusion", как два элемента в списке аргументов:

    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 затем переходит в состояние Starting, а когда программа запущена, QProcess переходит в состояние Running и излучает started().

QProcess позволяет рассматривать процесс как последовательное устройство ввода-вывода. Вы можете писать и читать в процесс так же, как вы бы обращались к сетевому соединению с помощью QTcpSocket. Затем вы можете записать в стандартный ввод процесса, вызвав write(), и прочитать стандартный вывод, вызвав read(), readLine() и getChar(). Поскольку он наследуется от QIODevice, QProcess также может использоваться в качестве источника входных данных для QXmlReader или для генерации данных для загрузки с помощью QNetworkAccessManager.

Когда процесс завершается, QProcess возвращается в состояние NotRunning (начальное состояние) и излучает finished().

Сигнал finished() предоставляет код завершения и статус завершения процесса в качестве аргументов, и вы также можете вызвать exitCode(), чтобы получить код завершения последнего завершенного процесса, и exitStatus(), чтобы получить его статус завершения. Если в какой-либо момент времени произойдет ошибка, QProcess излучит сигнал errorOccurred(). Вы также можете вызвать error(), чтобы найти тип ошибки, которая произошла в последний раз, и state(), чтобы найти текущее состояние процесса.

Примечание: QProcess не поддерживается на платформах VxWorks, iOS, tvOS, watchOS или Universal Windows Platform.

Взаимодействие через каналы

Процессы имеют два предопределенных канала вывода: канал стандартного вывода (stdout) предоставляет обычный вывод консоли, а канал стандартной ошибки (stderr) обычно предоставляет ошибки, которые печатает процесс. Эти каналы представляют собой два отдельных потока данных. Вы можете переключаться между ними, вызывая setReadChannel(). QProcess излучает readyRead(), когда данные доступны в текущем канале чтения. Он также излучает readyReadStandardOutput(), когда доступны новые данные стандартного вывода, и когда доступны новые данные стандартной ошибки, излучается readyReadStandardError(). Вместо вызова read(), readLine() или getChar(), вы можете явно прочитать все данные из любого из двух каналов, вызвав readAllStandardOutput() или readAllStandardError().

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

QProcess может объединять два выходных канала, так что данные стандартного вывода и стандартной ошибки от выполняемого процесса используют один канал стандартного вывода. Вызовите setProcessChannelMode() с MergedChannels перед запуском процесса, чтобы активировать эту функцию. У вас также есть возможность перенаправить вывод выполняемого процесса в вызывающий, основной процесс, передав ForwardedChannels в качестве аргумента. Также возможно перенаправить только один из выходных каналов — обычно используется ForwardedErrorChannel, но также существует ForwardedOutputChannel. Обратите внимание, что использование перенаправления каналов обычно является плохой идеей в приложениях с графическим интерфейсом — вместо этого вы должны отображать ошибки графически.

Некоторые процессы требуют специальных настроек среды для работы. Вы можете установить переменные среды для своего процесса, вызвав setProcessEnvironment(). Для установки рабочей директории вызовите setWorkingDirectory(). По умолчанию процессы выполняются в текущей рабочей директории вызывающего процесса.

Расположение и порядок отображения окон, принадлежащих приложениям с графическим интерфейсом, запущенным с помощью QProcess, контролируются базовой системой управления окнами. В приложениях Qt 5 расположение можно указать, используя опцию командной строки -qwindowgeometry; приложения X11 обычно принимают опцию командной строки -geometry.

Примечание: В QNX установка рабочей директории может привести к временному зависанию всех потоков приложения, за исключением потока вызова QProcess, во время процесса запуска из-за ограничения операционной системы.

Синхронный API процессов

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

• waitForStarted() приостанавливает выполнение, пока процесс не будет запущен.
• waitForReadyRead() приостанавливает выполнение, пока новые данные не станут доступны для чтения в текущем канале чтения.
• waitForBytesWritten() приостанавливает выполнение, пока один пакет данных не будет записан в процесс.
• waitForFinished() приостанавливает выполнение, пока процесс не завершится.

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

В следующем примере выполняется gzip для сжатия строки "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.

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

typedef QProcess::CreateProcessArgumentModifier

Примечание: Этот typedef доступен только в настольных версиях Windows.

В 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().

enum QProcess::ExitStatus

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

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

enum QProcess::InputChannelMode

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

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

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

enum QProcess::ProcessChannel

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

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

enum QProcess::ProcessChannelMode

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

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

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

enum QProcess::ProcessError

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

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

enum QProcess::ProcessState

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

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

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

QProcess::QProcess(QObject *parent = nullptr)

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

[virtual] QProcess::~QProcess()

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

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

QStringList QProcess::arguments() const

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

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

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

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

Переопределено из QIODevice::atEnd().

Возвращает true если процесс не запущен и больше нет данных для чтения; в противном случае возвращает false.

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

Переопределено из QIODevice::bytesAvailable().

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

Переопределено из QIODevice::bytesToWrite().

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

Переопределено из QIODevice::canReadLine().

Эта функция работает с текущим каналом чтения.

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

[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().

QProcess::CreateProcessArgumentModifier QProcess::createProcessArgumentsModifier() const

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

Примечание: Эта функция доступна только на платформе Windows.

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

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

QProcess::ProcessError QProcess::error() const

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

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

[signal] void QProcess::errorOccurred(QProcess::ProcessError error)

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

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

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

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

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

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

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

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

[static] int QProcess::execute(const QString &command)

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

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

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

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

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

int QProcess::exitCode() const

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

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

QProcess::ExitStatus QProcess::exitStatus() const

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

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

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

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

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

Примечание: Сигнал finished перегружен в этом классе. Для подключения к этому сигналу с помощью синтаксиса указателя функции Qt предоставляет удобный помощник для получения указателя функции, как показано в этом примере:

connect(process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
    [=](int exitCode, QProcess::ExitStatus exitStatus){ /* ... */ });

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

QProcess::InputChannelMode QProcess::inputChannelMode() const

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

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

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

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

Переопределено из QIODevice::isSequential().

[slot] void QProcess::kill()

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

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

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

QString QProcess::nativeArguments() const

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

Примечание: Эта функция доступна только на платформе Windows.

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

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

[static] QString QProcess::nullDevice()

Пустой файл (null device) операционной системы.

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

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

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

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

Переопределено из QIODevice::open().

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

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

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

QProcess::ProcessChannelMode QProcess::processChannelMode() const

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

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

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

QProcessEnvironment QProcess::processEnvironment() const

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

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

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

qint64 QProcess::processId() const

Возвращает идентификатор процесса (native process identifier) для работающего процесса, если доступен. Если в данный момент процесс не выполняется, возвращается 0.

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

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().

[signal] void QProcess::readyReadStandardError()

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

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

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

[signal] void QProcess::readyReadStandardOutput()

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

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

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

void QProcess::setArguments(const QStringList &arguments)

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

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

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

void QProcess::setCreateProcessArgumentsModifier(QProcess::CreateProcessArgumentModifier modifier)

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

Примечание: Эта функция доступна только на платформе Windows и требует C++11.

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

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

void QProcess::setInputChannelMode(QProcess::InputChannelMode mode)

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

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

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

void QProcess::setNativeArguments(const QString &arguments)

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

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

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

Примечание: Эта функция доступна только на платформе Windows.

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

См. также 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();

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

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

void QProcess::setProcessEnvironment(const QProcessEnvironment &environment)

Устанавливает 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 имена переменных окружения нечувствительны к регистру.

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

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

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

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

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

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, QIODevice::OpenMode mode = Truncate)

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

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

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

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

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

void QProcess::setStandardInputFile(const QString &fileName)

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

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

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

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

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

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

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

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

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

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

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

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

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

См. также 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");

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

void QProcess::setWorkingDirectory(const QString &dir)

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

Примечание: В QNX это может привести к временному зависанию всех потоков приложения.

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

[virtual protected] void QProcess::setupChildProcess()

Эта функция вызывается в контексте дочернего процесса незадолго до выполнения программы в Unix или macOS (т.е., после fork(), но перед execve()). Переопределите эту функцию для выполнения последней инициализации дочернего процесса. Пример:

class SandboxProcess : public QProcess
{
    ...
 protected:
     void setupChildProcess() override;
    ...
};

void SandboxProcess::setupChildProcess()
{
    // Drop all privileges in the child process, and enter
    // a chroot jail.
#if defined Q_OS_UNIX
    ::setgroups(0, 0);
    ::chroot("/etc/safe");
    ::chdir("/");
    ::setgid(safeGid);
    ::setuid(safeUid);
    ::umask(0);
#endif
}

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

Предупреждение: Эта функция вызывается объектом QProcess только в Unix и macOS. В Windows и QNX она не вызывается.

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

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

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

Примечание: Процессы запускаются асинхронно, что означает, что сигналы started и errorOccurred могут быть задержены. Вызовите waitForStarted(), чтобы убедиться, что процесс запущен (или запуск завершился неудачей) и эти сигналы были эмитированы.

Примечание: Дальнейшее разделение аргументов не выполняется.

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

Режим открытия устанавливается в mode.

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

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

void QProcess::start(const QString &command, QIODevice::OpenMode mode = ReadWrite)

Это перегруженный метод.

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

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

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

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

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

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

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

После того, как строка command была разделена и обработаны кавычки, этот метод ведет себя так же, как перегрузка, которая принимает аргументы в виде списка строк.

Вы можете отключить эту перегрузку, определив QT_NO_PROCESS_COMBINED_ARGUMENT_START при компиляции ваших приложений. Это может быть полезно, если вы хотите убедиться, что аргументы не разделяются непреднамеренно, например. Практически во всех случаях использование другой перегрузки является предпочтительным методом.

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

void QProcess::start(QIODevice::OpenMode mode = ReadWrite)

Это перегруженный метод.

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

Этот метод был добавлен в Qt 5.1.

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

bool QProcess::startDetached(qint64 *pid = nullptr)

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

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

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

Примечание: В QNX это может привести к временному зависанию всех потоков приложения.

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

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

• setArguments()
• setCreateProcessArgumentsModifier()
• setNativeArguments()
• setProcessEnvironment()
• setProgram()
• setStandardErrorFile()
• setStandardInputFile()
• setStandardOutputFile()
• setWorkingDirectory()

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

Примечание: Вызываемый процесс наследует окно консоли вызывающего процесса. Чтобы подавить вывод консоли, перенаправьте стандартный/ошибочный вывод в QProcess::nullDevice().

Этот метод был добавлен в Qt 5.10.

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

[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().

[static] bool QProcess::startDetached(const QString &command)

Этот метод перегружает startDetached().

Запускает команду command в новом процессе и отделяется от него. Возвращает true при успехе; в противном случае возвращает false.

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

После разделения строки command и обработки кавычек этот метод ведет себя как перегрузка, принимающая аргументы в виде списка строк.

См. также start(const QString &command, OpenMode mode).

[signal] void QProcess::started()

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

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

QProcess::ProcessState QProcess::state() const

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

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

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

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

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

[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()

Этот метод был добавлен в Qt 4.1.

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

[slot] void QProcess::terminate()

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

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

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

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

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

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

Переопределено из QIODevice::waitForBytesWritten().

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().

bool QProcess::waitForStarted(int msecs = 30000)

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

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

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

Предупреждение: Вызов этой функции из главного (графического) потока может привести к зависанию пользовательского интерфейса.

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

Примечание: На некоторых операционных системах Unix эта функция может вернуть true, но процесс может позже сообщить об ошибке QProcess::FailedToStart.

См. также 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().