Класс QProcess

Класс 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.

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

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

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

Эта функция была добавлена в 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.

См. также 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 для вызова 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 немедленно перейдет в состояние «Запуск». Если процесс запустится успешно, 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().

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

См. также 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 уже завершён).

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

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

Если 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, эта функция не будет ожидать таймаут.

Примечание: В некоторых операционных системах 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).