QProcess Class

Documentación de Funciones Miembro

[explicit] QProcess::QProcess(QObject *parent = nullptr)

Construye un objeto QProcess con la dirección parent.

[virtual noexcept] QProcess::~QProcess()

Destruye el objeto QProcess, es decir, mata el proceso.

Tenga en cuenta que esta función no regresará hasta que el proceso haya terminado.

QStringList QProcess::arguments() const

Devuelve los argumentos de línea de comandos con los que se inició el proceso por última vez.

Véase también setArguments() y start().

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

Reimplementa: QIODevice::bytesToWrite() const.

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

Devuelve la función modificadora establecida previamente llamando a setChildProcessModifier().

Esta función se introdujo en Qt 6.0.

Véase también setChildProcessModifier() y unixProcessParameters().

[override virtual] void QProcess::close()

Reimplementa: QIODevice::close().

Cierra toda comunicación con el proceso y lo mata. Después de llamar a esta función, QProcess ya no emitirá readyRead(), y ya no se podrán leer ni escribir datos.

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

Cierra el canal de lectura channel. Después de llamar a esta función, QProcess dejará de recibir datos en el canal. Cualquier dato que ya haya sido recibido seguirá estando disponible para su lectura.

Llama a esta función para ahorrar memoria, si no estás interesado en la salida del proceso.

Ver también closeWriteChannel() y setReadChannel().

void QProcess::closeWriteChannel()

Programa el cierre del canal de escritura de QProcess. El canal se cerrará una vez que todos los datos hayan sido escritos en el proceso. Después de llamar a esta función, cualquier intento de escribir al proceso fallará.

Cerrar el canal de escritura es necesario para programas que leen datos de entrada hasta que el canal ha sido cerrado. Por ejemplo, el programa "more" se utiliza para mostrar datos de texto en una consola tanto en Unix como en Windows. Pero no mostrará los datos de texto hasta que el canal de escritura de QProcess se haya cerrado. Ejemplo:

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

El canal de escritura se abre implícitamente cuando se llama a start().

Véase también closeReadChannel().

QProcess::CreateProcessArgumentModifier QProcess::createProcessArgumentsModifier() const

Devuelve una función modificadora de CreateProcess previamente establecida.

Véase también setCreateProcessArgumentsModifier() y QProcess::CreateProcessArgumentModifier.

QProcess::ProcessError QProcess::error() const

Devuelve el tipo de error que se ha producido en último lugar.

Véase también state().

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

Esta señal se emite cuando se produce un error en el proceso. El error especificado describe el tipo de error que se ha producido.

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

Inicia el programa program con los argumentos arguments en un nuevo proceso, espera a que termine y devuelve el código de salida del proceso. Cualquier dato que el nuevo proceso escriba en la consola es reenviado al proceso llamante.

El entorno y el directorio de trabajo se heredan del proceso de llamada.

El tratamiento de los argumentos es idéntico al de la sobrecarga start().

Si el proceso no puede iniciarse, se devuelve -2. Si el proceso falla, se devuelve -1. En caso contrario, se devuelve el código de salida del proceso.

Véase también start().

int QProcess::exitCode() const

Devuelve el código de salida del último proceso que finalizó.

Este valor no es válido a menos que exitStatus() devuelva NormalExit.

QProcess::ExitStatus QProcess::exitStatus() const

Devuelve el estado de salida del último proceso que finalizó.

En Windows, si el proceso finalizó con TerminateProcess() desde otra aplicación, esta función seguirá devolviendo NormalExit a menos que el código de salida sea menor que 0.

[noexcept, since 6.7] void QProcess::failChildProcessModifier(const char *description, int error = 0)

Estas funciones se pueden utilizar dentro del conjunto de modificadores con setChildProcessModifier() para indicar que se ha encontrado una condición de error. Cuando el modificador llama a estas funciones, QProcess emitirá errorOccurred() con el código QProcess::FailedToStart en el proceso padre. El parámetro description puede ser usado para incluir alguna información en errorString() para ayudar a diagnosticar el problema, usualmente el nombre de la llamada que falló, similar a la función de la librería C perror(). Adicionalmente, el parámetro error puede ser un código de error <errno.h> cuya forma de texto también será incluida.

Por ejemplo, un modificador hijo podría preparar un descriptor de fichero extra para el proceso hijo de esta forma:

process.setChildProcessModifier([fd, &process]() {
    if (dup2(fd, TargetFileDescriptor) < 0)
        process.failChildProcessModifier(errno, "aux comm channel");
});
process.start();

Donde fd es un descriptor de fichero actualmente abierto en el proceso padre. Si la llamada al sistema dup2() resultó en una condición EBADF, el proceso errorString() podría ser "Child process modifier reported error: aux comm channel: Bad file descriptor".

Esta función no retorna a quien la llama. Usarla en cualquier lugar excepto en el modificador hijo y con el objeto QProcess correcto es un comportamiento indefinido.

Esta función se introdujo en Qt 6.7.

Véase también setChildProcessModifier() y setUnixProcessParameters().

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

Esta señal se emite cuando el proceso termina. exitCode es el código de salida del proceso (sólo válido para salidas normales), y exitStatus es el estado de salida. Una vez finalizado el proceso, los buffers de QProcess siguen intactos. Aún puedes leer cualquier dato que el proceso haya escrito antes de terminar.

Véase también exitStatus().

QProcess::InputChannelMode QProcess::inputChannelMode() const

Devuelve el modo del canal de entrada estándar QProcess.

Véase también setInputChannelMode() y InputChannelMode.

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

Reimplementa: QIODevice::isSequential() const.

[slot] void QProcess::kill()

Mata el proceso actual, provocando su salida inmediata.

En Windows, kill() utiliza TerminateProcess, y en Unix y macOS, se envía la señal SIGKILL al proceso.

Véase también terminate().

QString QProcess::nativeArguments() const

Devuelve los argumentos nativos adicionales de la línea de comandos del programa.

Véase también setNativeArguments().

[static] QString QProcess::nullDevice()

El dispositivo nulo del sistema operativo.

La ruta de archivo devuelta utiliza separadores de directorio nativos.

Véase también QProcess::setStandardInputFile(), QProcess::setStandardOutputFile(), y QProcess::setStandardErrorFile().

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

Reimplementa: QIODevice::open(QIODeviceBase::OpenMode mode).

Inicia el programa establecido por setProgram() con los argumentos establecidos por setArguments(). El OpenMode se establece en mode.

Este método es un alias de start(), y sólo existe para implementar completamente la interfaz definida por QIODevice.

Devuelve true si el programa se ha iniciado.

Véase también start(), setProgram(), y setArguments().

QProcess::ProcessChannelMode QProcess::processChannelMode() const

Devuelve el modo de canal de los canales de salida estándar y error estándar de QProcess.

Véase también setProcessChannelMode(), ProcessChannelMode, y setReadChannel().

QProcessEnvironment QProcess::processEnvironment() const

Devuelve el entorno que QProcess pasará a su proceso hijo. Si no se ha establecido ningún entorno mediante setProcessEnvironment(), este método devuelve un objeto que indica que el entorno se heredará del padre.

Véase también setProcessEnvironment(), QProcessEnvironment::inheritsFromParent(), y Environment variables.

qint64 QProcess::processId() const

Devuelve el identificador nativo del proceso en ejecución, si está disponible. Si no hay ningún proceso en ejecución, se devuelve 0.

QString QProcess::program() const

Devuelve el programa con el que se inició el proceso por última vez.

Véase también setProgram() y start().

QByteArray QProcess::readAllStandardError()

Independientemente del canal de lectura actual, esta función devuelve todos los datos disponibles del error estándar del proceso como QByteArray.

Véase también readyReadStandardError(), readAllStandardOutput(), readChannel(), y setReadChannel().

QByteArray QProcess::readAllStandardOutput()

Independientemente del canal de lectura actual, esta función devuelve todos los datos disponibles de la salida estándar del proceso como QByteArray.

Véase también readyReadStandardOutput(), readAllStandardError(), readChannel(), y setReadChannel().

QProcess::ProcessChannel QProcess::readChannel() const

Devuelve el canal de lectura actual de QProcess.

Véase también setReadChannel().

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

Reimplementa: QIODevice::readData(char *data, qint64 maxSize).

[private signal] void QProcess::readyReadStandardError()

Esta señal se emite cuando el proceso ha puesto a disposición nuevos datos a través de su canal de error estándar (stderr). Se emite independientemente del read channel actual.

Véase también readAllStandardError() y readChannel().

[private signal] void QProcess::readyReadStandardOutput()

Esta señal se emite cuando el proceso ha puesto a disposición nuevos datos a través de su canal de salida estándar (stdout). Se emite independientemente del read channel actual.

Véase también readAllStandardOutput() y readChannel().

void QProcess::setArguments(const QStringList &arguments)

Establece el arguments a pasar al programa llamado al iniciar el proceso. Esta función debe ser llamada antes de start().

Ver también start(), setProgram(), y arguments().

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

Establece la función modifier para el proceso hijo, para sistemas Unix (incluido macOS; para Windows, véase setCreateProcessArgumentsModifier()). La función contenida por el argumento modifier será invocada en el proceso hijo después de que fork() o vfork() se hayan completado y QProcess haya configurado los descriptores de archivo estándar para el proceso hijo, pero antes de execve(), dentro de start().

A continuación se muestra un ejemplo de configuración de un proceso hijo para que se ejecute sin privilegios:

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

Si la función modificadora experimenta una condición de fallo, puede utilizar failChildProcessModifier() para informar de la situación a la persona que llama a QProcess. Alternativamente, puede utilizar otros métodos para detener el proceso, como _exit(), o abort().

Ciertas propiedades del proceso hijo, como cerrar todos los descriptores de fichero extraños o desconectarse del TTY controlador, pueden conseguirse más fácilmente utilizando setUnixProcessParameters(), que puede detectar el fallo e informar de una condición FailedToStart. El modificador es útil para cambiar ciertas propiedades poco comunes del proceso hijo, como establecer descriptores de fichero adicionales. Si se establecen tanto un modificador de proceso hijo como parámetros de proceso Unix, el modificador se ejecuta antes de que se apliquen estos parámetros.

Esta función se introdujo en Qt 6.0.

Véase también childProcessModifier(), failChildProcessModifier(), y setUnixProcessParameters().

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

Establece el modifier para la llamada a la API Win32 CreateProcess. Pase QProcess::CreateProcessArgumentModifier() para eliminar uno previamente establecido.

Véase también createProcessArgumentsModifier(), QProcess::CreateProcessArgumentModifier, y setChildProcessModifier().

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

Establece el modo de canal del canal de entrada estándar QProcess al mode especificado. Este modo se utilizará la próxima vez que se llame a start().

Véase también inputChannelMode() y InputChannelMode.

void QProcess::setNativeArguments(const QString &arguments)

Establece la línea de comandos nativa adicional arguments para el programa.

En los sistemas operativos en los que la API del sistema para pasar la línea de comandos arguments a un subproceso utiliza de forma nativa una única cadena, se pueden concebir líneas de comandos que no se pueden pasar a través de la API basada en listas portátiles de QProcess. En tales casos, esta función debe utilizarse para establecer una cadena que se anexa a la cadena compuesta a partir de la lista de argumentos habitual, con un espacio delimitador.

Véase también nativeArguments().

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

Establece el modo de canal de los canales de salida estándar y de error estándar de QProcess al especificado en mode. Este modo se utilizará la próxima vez que se llame a start(). Por ejemplo:

QProcess builder; builder.setProcessChannelMode(QProcess::MergedChannels); builder.start("make", QStringList()<< "-j2");if (!builder.waitForFinished())    qDebug() << "Make failed:" << builder.errorString();
si no    qDebug() << "Make output:" << builder.readAll();

Véase también processChannelMode(), ProcessChannelMode, y setReadChannel().

void QProcess::setProcessEnvironment(const QProcessEnvironment &environment)

Establece la environment que QProcess pasará al proceso hijo.

Por ejemplo, el siguiente código añade la variable de entorno TMPDIR:

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

Tenga en cuenta que, en Windows, los nombres de las variables de entorno no distinguen entre mayúsculas y minúsculas.

Ver también processEnvironment(), QProcessEnvironment::systemEnvironment(), y Environment variables.

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

Establece el estado actual de QProcess al state especificado.

Véase también state().

void QProcess::setProgram(const QString &program)

Establece el program que se utilizará al iniciar el proceso. Esta función debe llamarse antes de start().

Si program es una ruta absoluta, especifica el ejecutable exacto que se lanzará. Las rutas relativas se resolverán de una manera específica de la plataforma, que incluye la búsqueda en la variable de entorno PATH (véase Finding the Executable para más detalles).

Véase también start(), setArguments(), program() y QStandardPaths::findExecutable().

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

Establece el canal de lectura actual de QProcess en channel. El canal de entrada actual es utilizado por las funciones read(), readAll(), readLine(), y getChar(). También determina qué canal activa QProcess para emitir readyRead().

Véase también readChannel().

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

Redirige el error estándar del proceso al fichero fileName. Cuando la redirección está en marcha, el canal de lectura del error estándar está cerrado: leer de él usando read() siempre fallará, al igual que readAllStandardError(). El archivo será anexado si mode es Append, de lo contrario, será truncado.

Consulte setStandardOutputFile() para obtener más información sobre cómo se abre el archivo.

Nota: si setProcessChannelMode() fue llamada con un argumento de QProcess::MergedChannels, esta función no tiene efecto.

Véase también setStandardInputFile(), setStandardOutputFile(), y setStandardOutputProcess().

void QProcess::setStandardInputFile(const QString &fileName)

Redirige la entrada estándar del proceso al fichero indicado por fileName. Cuando se realiza una redirección de entrada, el objeto QProcess estará en modo de sólo lectura (llamar a write() producirá un error).

Para hacer que el proceso lea EOF inmediatamente, pase nullDevice() aquí. Esto es más limpio que usar closeWriteChannel() antes de escribir cualquier dato, porque puede configurarse antes de iniciar el proceso.

Si el fichero fileName no existe en el momento en que se llama a start() o no es legible, el inicio del proceso fallará.

Llamar a setStandardInputFile() después de que el proceso se haya iniciado no tiene ningún efecto.

Ver también setStandardOutputFile(), setStandardErrorFile(), y setStandardOutputProcess().

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

Redirige la salida estándar del proceso al fichero fileName. Cuando la redirección está en marcha, el canal de lectura de la salida estándar está cerrado: leer de él usando read() siempre fallará, al igual que readAllStandardOutput().

Para descartar toda la salida estándar del proceso, pase nullDevice() aquí. Esto es más eficiente que simplemente no leer nunca la salida estándar, ya que no se llenan los buffers de QProcess.

Si el fichero fileName no existe en el momento de llamar a start(), se creará. Si no se puede crear, el arranque fallará.

Si el fichero existe y mode es QIODeviceBase::Truncate, el fichero se truncará. De lo contrario (si mode es QIODeviceBase::Append), el archivo será anexado.

Llamar a setStandardOutputFile() después de que el proceso se haya iniciado no tiene ningún efecto.

Si fileName es una cadena vacía, deja de redirigir la salida estándar. Esto es útil para restaurar la salida estándar después de la redirección.

Vea también setStandardInputFile(), setStandardErrorFile(), y setStandardOutputProcess().

void QProcess::setStandardOutputProcess(QProcess *destination)

Canaliza el flujo de salida estándar de este proceso a la entrada estándar del proceso destination.

El siguiente comando de shell:

command1 | command2

Se puede lograr con QProcess con el siguiente código:

QProcess process1;
QProcess process2;

process1.setStandardOutputProcess(&process2);

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

[since 6.6] void QProcess::setUnixProcessParameters(const QProcess::UnixProcessParameters &params)

Establece los ajustes y parámetros adicionales para el proceso hijo en sistemas Unix que se params. Esta función puede utilizarse para pedir a QProcess que modifique el proceso hijo antes de lanzar el ejecutable de destino.

Esta función puede usarse para cambiar ciertas propiedades del proceso hijo, como cerrar todos los descriptores de fichero extraños, cambiar el nivel de nice del hijo, o desconectarse del TTY controlador. Para un control más preciso del proceso hijo o para modificarlo de otras formas, utilice la función setChildProcessModifier(). Si se establecen tanto un modificador de proceso hijo como parámetros de proceso Unix, el modificador se ejecuta antes de que se apliquen estos parámetros.

Esta función se introdujo en Qt 6.6.

Véase también unixProcessParameters() y setChildProcessModifier().

[since 6.6] void QProcess::setUnixProcessParameters(QProcess::UnixProcessFlags flagsOnly)

Establece la configuración extra para el proceso hijo en sistemas Unix a flagsOnly. Esto es lo mismo que la sobrecarga con sólo el campo flags establecido.

Esta función se introdujo en Qt 6.6.

Véase también unixProcessParameters() y setChildProcessModifier().

void QProcess::setWorkingDirectory(const QString &dir)

Establece el directorio de trabajo en dir. QProcess iniciará el proceso en este directorio. El comportamiento por defecto es iniciar el proceso en el directorio de trabajo del proceso que llama.

Véase también workingDirectory() y start().

[static] QStringList QProcess::splitCommand(QStringView command)

Divide la cadena command en una lista de símbolos y devuelve la lista.

Los tokens con espacios pueden ir rodeados de comillas dobles; tres comillas dobles consecutivas representan el carácter de comilla propiamente dicho.

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

Inicia el program dado en un nuevo proceso, pasando los argumentos de la línea de comandos en arguments. Ver setProgram() para información sobre cómo QProcess busca el ejecutable a ejecutar. El OpenMode se establece en mode. No se realiza ninguna otra división de los argumentos.

El objeto QProcess entrará inmediatamente en el estado Starting. Si el proceso se inicia con éxito, QProcess emitirá started(); en caso contrario, se emitirá errorOccurred(). Tenga en cuenta que en las plataformas que son capaces de iniciar procesos hijos de forma sincrónica (especialmente Windows), esas señales se emitirán antes de que esta función regrese y este objeto QProcess pasará al estado QProcess::Running o QProcess::NotRunning, respectivamente. En otras plataformas, las señales started() y errorOccurred() se retrasarán.

Llame a waitForStarted() para asegurarse de que el proceso ha comenzado (o ha fallado al comenzar) y esas señales han sido emitidas. Es seguro llamar a esa función incluso si ya se conoce el estado de inicio del proceso, aunque la señal no se emitirá de nuevo.

Windows: Los argumentos se entrecomillan y se unen en una línea de comandos compatible con la función CommandLineToArgvW() de Windows. Para los programas que tienen diferentes requisitos de entrecomillado de la línea de comandos, es necesario utilizar setNativeArguments(). Un programa notable que no sigue las reglas de CommandLineToArgvW() es cmd.exe y, en consecuencia, todos los scripts por lotes.

Si el objeto QProcess ya está ejecutando un proceso, es posible que se imprima una advertencia en la consola, y el proceso existente continuará ejecutándose sin verse afectado.

Véase también processId(), started(), waitForStarted(), y setNativeArguments().

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

Inicia el programa establecido por setProgram() con los argumentos establecidos por setArguments(). El OpenMode se establece en mode.

Véase también open(), setProgram(), y setArguments().

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

Inicia el comando command en un nuevo proceso. El OpenMode se establece en mode.

command es una única cadena de texto que contiene el nombre del programa y sus argumentos. Los argumentos están separados por uno o más espacios. Por ejemplo:

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

Los argumentos que contienen espacios deben entrecomillarse para que se suministren correctamente al nuevo proceso. Por ejemplo:

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

Las comillas literales en la cadena command se representan mediante comillas triples. Por ejemplo:

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

Una vez que la cadena command ha sido dividida y desentrecomillada, esta función se comporta como start().

En los sistemas operativos en los que la API del sistema para pasar argumentos de línea de comandos a un subproceso utiliza de forma nativa una única cadena (Windows), se pueden concebir líneas de comandos que no se pueden pasar a través de la API portátil basada en listas de QProcess. En estos raros casos es necesario utilizar setProgram() y setNativeArguments() en lugar de esta función.

Esta función se introdujo en Qt 6.0.

Véase también splitCommand() y start().

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

Inicia el programa establecido por setProgram() con los argumentos establecidos por setArguments() en un nuevo proceso, y se separa de él. Devuelve true en caso de éxito; en caso contrario devuelve false. Si el proceso que llama sale, el proceso separado continuará ejecutándose sin verse afectado.

Unix: El proceso iniciado se ejecutará en su propia sesión y actuará como un demonio.

El proceso se iniciará en el directorio establecido por setWorkingDirectory(). Si workingDirectory() está vacío, el directorio de trabajo se hereda del proceso de llamada.

Si la función tiene éxito, entonces *pid se establece al identificador de proceso del proceso iniciado; de lo contrario, se establece a -1. Tenga en cuenta que el proceso hijo puede salir y el PID puede dejar de ser válido sin previo aviso. Además, después de que el proceso hijo salga, el mismo PID puede ser reciclado y usado por un proceso completamente diferente. El código de usuario debe ser cuidadoso al utilizar esta variable, especialmente si se pretende terminar forzosamente el proceso por medios del sistema operativo.

startDetached() sólo admite los siguientes definidores de propiedades:

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

Todas las demás propiedades del objeto QProcess son ignoradas.

Ver también start() y startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory, qint64 *pid).

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

Inicia el programa program con los argumentos arguments en un nuevo proceso, y se separa de él. Devuelve true en caso de éxito; en caso contrario devuelve false. Si el proceso que llama sale, el proceso separado continuará ejecutándose sin verse afectado.

El manejo de los argumentos es idéntico al de la sobrecarga start().

El proceso se iniciará en el directorio workingDirectory. Si workingDirectory está vacío, el directorio de trabajo se hereda del proceso de llamada.

Si la función tiene éxito entonces *pid se establece al identificador de proceso del proceso iniciado.

Véase también start().

[private signal] void QProcess::started()

Esta señal es emitida por QProcess cuando el proceso ha comenzado, y state() devuelve Running.

QProcess::ProcessState QProcess::state() const

Devuelve el estado actual del proceso.

Véase también stateChanged() y error().

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

Esta señal se emite cada vez que cambia el estado de QProcess. El argumento newState es el estado al que ha cambiado QProcess.

[static] QStringList QProcess::systemEnvironment()

Devuelve el entorno del proceso de llamada como una lista de pares clave=valor. Ejemplo:

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

Esta función no almacena en caché el entorno del sistema. Por lo tanto, es posible obtener una versión actualizada del entorno si se ha llamado a funciones de biblioteca C de bajo nivel como setenv o putenv.

Sin embargo, tenga en cuenta que las llamadas repetidas a esta función volverán a crear la lista de variables de entorno, que es una operación no trivial.

Véase también QProcessEnvironment::systemEnvironment() y setProcessEnvironment().

[slot] void QProcess::terminate()

Intenta terminar el proceso.

El proceso puede no salir como resultado de llamar a esta función (se le da la oportunidad de preguntar al usuario por cualquier archivo no guardado, etc).

En Windows, terminate() envía un mensaje WM_CLOSE a todas las ventanas de nivel superior del proceso y luego al hilo principal del propio proceso. En Unix y macOS se envía la señal SIGTERM.

Las aplicaciones de consola en Windows que no ejecutan un bucle de eventos, o cuyo bucle de eventos no maneja el mensaje WM_CLOSE, sólo pueden ser terminadas llamando a kill().

Véase también kill().

[noexcept, since 6.6] QProcess::UnixProcessParameters QProcess::unixProcessParameters() const

Devuelve el objeto UnixProcessParameters que describe banderas y configuraciones adicionales que se aplicarán al proceso hijo en sistemas Unix. La configuración por defecto corresponde a un UnixProcessParameters construido por defecto.

Esta función se introdujo en Qt 6.6.

Véase también setUnixProcessParameters() y childProcessModifier().

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

Reimplementa: QIODevice::waitForBytesWritten(int msecs).

bool QProcess::waitForFinished(int msecs = 30000)

Bloquea hasta que el proceso ha terminado y la señal finished() ha sido emitida, o hasta que msecs milisegundos han pasado.

Devuelve true si el proceso ha finalizado; en caso contrario, devuelve false (si la operación ha expirado, si se ha producido un error o si QProcess ya ha finalizado).

Esta función puede operar sin un bucle de eventos. Es útil cuando se escriben aplicaciones no-GUI y cuando se realizan operaciones de E/S en un hilo no-GUI.

Si msecs es -1, esta función no expirará.

Ver también finished(), waitForStarted(), waitForReadyRead(), y waitForBytesWritten().

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

Reimplementa: QIODevice::waitForReadyRead(int msecs).

bool QProcess::waitForStarted(int msecs = 30000)

Bloquea hasta que el proceso se ha iniciado y se ha emitido la señal started(), o hasta que han transcurrido msecs milisegundos.

Devuelve true si el proceso se ha iniciado con éxito; en caso contrario devuelve false (si la operación ha finalizado o si se ha producido un error). Si el proceso ya se había iniciado con éxito antes de esta función, devuelve inmediatamente.

Esta función puede operar sin un bucle de eventos. Es útil cuando se escriben aplicaciones no-GUI y cuando se realizan operaciones de E/S en un hilo no-GUI.

Si msecs es -1, esta función no expirará.

Ver también started(), waitForReadyRead(), waitForBytesWritten(), y waitForFinished().

QString QProcess::workingDirectory() const

Si se ha asignado un directorio de trabajo a QProcess, esta función devuelve el directorio de trabajo en el que entrará QProcess antes de que se inicie el programa. En caso contrario (es decir, si no se ha asignado ningún directorio), se devuelve una cadena vacía y QProcess utilizará en su lugar el directorio de trabajo actual de la aplicación.

Véase también setWorkingDirectory().