Класс QProcess

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

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

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

Типы

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

Реализованные публичные функции

Публичные слоты

Сигналы

Статические публичные члены

Protected Functions

Reimplemented Protected Functions

Related Non-Members

Macros

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.

Note: QProcess is not supported on VxWorks, iOS, tvOS, watchOS, or the Universal Windows Platform.

Communicating via Channels

Процессы имеют два предопределённых канала вывода: стандартный канал вывода (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().

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

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

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

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

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

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

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

QProcess::QProcess(QObject *parent = nullptr)

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

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

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

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

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

[slot] void QProcess::kill()

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

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

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

[signal] void QProcess::readyReadStandardError()

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

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

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

[signal] void QProcess::readyReadStandardOutput()

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

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

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

[signal] void QProcess::started()

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

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

[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, т.е. завершает процесс.

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

QStringList QProcess::arguments() const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QProcess::InputChannelMode QProcess::inputChannelMode() const

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

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

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

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

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

QString QProcess::nativeArguments() const

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

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

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

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

[static] QString QProcess::nullDevice()

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

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

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

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

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

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

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

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

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

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

Возвращает идентификатор процесса для выполняемого процесса, если доступен. Если процесс в настоящее время не выполняется, возвращается 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(char *data, qint64 maxSize).

void QProcess::setArguments(const QStringList &arguments)

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

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

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

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

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

Примечание: Эта функция доступна только на платформе 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. Например:

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 немедленно переходит в состояние запуска. Если процесс запустился успешно, QProcess отправит started(); в противном случае, будет отправлено errorOccurred().

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

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

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

Значение OpenMode установлено в 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().

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

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

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

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

См. также 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 уже завершился).

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

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

Если 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 (если операция истекла или произошла ошибка).

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

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

Примечание: На некоторых 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(const char *data, qint64 maxSize).