QProcess Class

Documentation des fonctions membres

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

Construit un objet QProcess avec l'adresse parent.

[virtual noexcept] QProcess::~QProcess()

Détruit l'objet QProcess, c'est-à-dire qu'elle tue le processus.

Notez que cette fonction ne revient pas tant que le processus n'est pas terminé.

QStringList QProcess::arguments() const

Renvoie les arguments de la ligne de commande avec lesquels le processus a été lancé pour la dernière fois.

Voir aussi setArguments() et start().

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

Réimplémente : QIODevice::bytesToWrite() const.

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

Renvoie la fonction modificatrice précédemment définie en appelant setChildProcessModifier().

Cette fonction a été introduite dans Qt 6.0.

Voir aussi setChildProcessModifier() et unixProcessParameters().

[override virtual] void QProcess::close()

Réimplémente : QIODevice::close().

Ferme toute communication avec le processus et le tue. Après l'appel de cette fonction, QProcess n'émettra plus readyRead() et les données ne pourront plus être lues ou écrites.

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

Ferme le canal de lecture channel. Après l'appel de cette fonction, QProcess ne recevra plus de données sur le canal. Les données déjà reçues restent disponibles pour la lecture.

Appelez cette fonction pour économiser de la mémoire, si vous n'êtes pas intéressé par la sortie du processus.

Voir aussi closeWriteChannel() et setReadChannel().

void QProcess::closeWriteChannel()

Planifie la fermeture du canal d'écriture de QProcess. Le canal sera fermé une fois que toutes les données auront été écrites dans le processus. Après l'appel de cette fonction, toute tentative d'écriture dans le processus échouera.

La fermeture du canal d'écriture est nécessaire pour les programmes qui lisent les données d'entrée jusqu'à ce que le canal soit fermé. Par exemple, le programme "more" est utilisé pour afficher des données textuelles dans une console sous Unix et Windows. Mais il n'affichera pas les données textuelles tant que le canal d'écriture de QProcess n'aura pas été fermé. Exemple :

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

Le canal d'écriture est implicitement ouvert lorsque start() est appelé.

Voir aussi closeReadChannel().

QProcess::CreateProcessArgumentModifier QProcess::createProcessArgumentsModifier() const

Renvoie une fonction modificatrice précédemment définie sur CreateProcess.

Voir aussi setCreateProcessArgumentsModifier() et QProcess::CreateProcessArgumentModifier.

QProcess::ProcessError QProcess::error() const

Renvoie le type d'erreur qui s'est produite en dernier.

Voir aussi state().

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

Ce signal est émis lorsqu'une erreur se produit dans le processus. L'adresse error spécifiée décrit le type d'erreur qui s'est produite.

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

Lance le programme program avec les arguments arguments dans un nouveau processus, attend qu'il se termine, puis renvoie le code de sortie du processus. Toutes les données que le nouveau processus écrit dans la console sont transmises au processus appelant.

L'environnement et le répertoire de travail sont hérités du processus appelant.

La gestion des arguments est identique à la surcharge start() correspondante.

Si le processus ne peut pas être lancé, -2 est renvoyé. Si le processus se bloque, -1 est renvoyé. Sinon, le code de sortie du processus est renvoyé.

Voir également start().

int QProcess::exitCode() const

Renvoie le code de sortie du dernier processus qui s'est terminé.

Cette valeur n'est valable que si exitStatus() renvoie NormalExit.

QProcess::ExitStatus QProcess::exitStatus() const

Renvoie l'état de sortie du dernier processus qui s'est terminé.

Sous Windows, si le processus a été terminé par TerminateProcess() à partir d'une autre application, cette fonction renvoie toujours NormalExit, sauf si le code de sortie est inférieur à 0.

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

Ces fonctions peuvent être utilisées dans l'ensemble de modificateurs avec setChildProcessModifier() pour indiquer qu'une condition d'erreur a été rencontrée. Lorsque le modificateur appelle ces fonctions, QProcess émet errorOccurred() avec le code QProcess::FailedToStart dans le processus parent. Le paramètre description peut être utilisé pour inclure des informations dans errorString() afin d'aider à diagnostiquer le problème, généralement le nom de l'appel qui a échoué, de manière similaire à la fonction de la bibliothèque C perror(). En outre, le paramètre error peut être un code d'erreur <errno.h> dont le texte sera également inclus.

Par exemple, un modificateur enfant peut préparer un descripteur de fichier supplémentaire pour le processus enfant de cette manière :

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

Où fd est un descripteur de fichier actuellement ouvert dans le processus parent. Si l'appel système dup2() a entraîné une condition EBADF, le processus errorString() pourrait être "Child process modifier reported error : aux comm channel : Bad file descriptor".

Cette fonction ne renvoie pas à l'appelant. L'utiliser ailleurs que dans le modificateur enfant et avec l'objet QProcess correct est un comportement indéfini.

Cette fonction a été introduite dans Qt 6.7.

Voir aussi setChildProcessModifier() et setUnixProcessParameters().

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

Ce signal est émis lorsque le processus se termine. exitCode est le code de sortie du processus (valable uniquement pour les sorties normales) et exitStatus est l'état de sortie. Une fois le processus terminé, les tampons de QProcess sont toujours intacts. Vous pouvez toujours lire les données que le processus a pu écrire avant de se terminer.

Voir aussi exitStatus().

QProcess::InputChannelMode QProcess::inputChannelMode() const

Renvoie le mode du canal d'entrée standard de QProcess.

Voir aussi setInputChannelMode() et InputChannelMode.

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

Réimplémente : QIODevice::isSequential() const.

[slot] void QProcess::kill()

Tue le processus en cours et le fait sortir immédiatement.

Sous Windows, kill() utilise TerminateProcess, et sous Unix et macOS, le signal SIGKILL est envoyé au processus.

Voir également terminate().

QString QProcess::nativeArguments() const

Renvoie les arguments natifs supplémentaires de la ligne de commande pour le programme.

Voir également setNativeArguments().

[static] QString QProcess::nullDevice()

Le périphérique null du système d'exploitation.

Le chemin d'accès au fichier retourné utilise les séparateurs de répertoire natifs.

Voir aussi QProcess::setStandardInputFile(), QProcess::setStandardOutputFile() et QProcess::setStandardErrorFile().

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

Réimplémente : QIODevice::open(QIODeviceBase::OpenMode mode).

Démarre le programme défini par setProgram() avec les arguments définis par setArguments(). L'OpenMode est défini sur mode.

Cette méthode est un alias de start() et n'existe que pour implémenter complètement l'interface définie par QIODevice.

Retourne true si le programme a été lancé.

Voir aussi start(), setProgram() et setArguments().

QProcess::ProcessChannelMode QProcess::processChannelMode() const

Renvoie le mode de canal des canaux de sortie et d'erreur standard de QProcess.

Voir aussi setProcessChannelMode(), ProcessChannelMode, et setReadChannel().

QProcessEnvironment QProcess::processEnvironment() const

Renvoie l'environnement que QProcess transmettra à son processus enfant. Si aucun environnement n'a été défini à l'aide de setProcessEnvironment(), cette méthode renvoie un objet indiquant que l'environnement sera hérité du parent.

Voir aussi setProcessEnvironment(), QProcessEnvironment::inheritsFromParent() et Environment variables.

qint64 QProcess::processId() const

Renvoie l'identifiant natif du processus en cours, s'il est disponible. Si aucun processus n'est en cours d'exécution, 0 est renvoyé.

QString QProcess::program() const

Renvoie le programme avec lequel le processus a été lancé pour la dernière fois.

Voir aussi setProgram() et start().

QByteArray QProcess::readAllStandardError()

Indépendamment du canal de lecture actuel, cette fonction renvoie toutes les données disponibles à partir de l'erreur standard du processus sous la forme d'un fichier QByteArray.

Voir aussi readyReadStandardError(), readAllStandardOutput(), readChannel() et setReadChannel().

QByteArray QProcess::readAllStandardOutput()

Indépendamment du canal de lecture actuel, cette fonction renvoie toutes les données disponibles sur la sortie standard du processus sous la forme d'un fichier QByteArray.

Voir aussi readyReadStandardOutput(), readAllStandardError(), readChannel() et setReadChannel().

QProcess::ProcessChannel QProcess::readChannel() const

Renvoie le canal de lecture actuel de QProcess.

Voir aussi setReadChannel().

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

Réimplémente : QIODevice::readData(char *data, qint64 maxSize).

[private signal] void QProcess::readyReadStandardError()

Ce signal est émis lorsque le processus a mis de nouvelles données à disposition via son canal d'erreur standard (stderr). Il est émis indépendamment de l'adresse read channel.

Voir également readAllStandardError() et readChannel().

[private signal] void QProcess::readyReadStandardOutput()

Ce signal est émis lorsque le processus a mis de nouvelles données à disposition via son canal de sortie standard (stdout). Il est émis indépendamment de l'adresse read channel.

Voir également readAllStandardOutput() et readChannel().

void QProcess::setArguments(const QStringList &arguments)

Définit l'adresse arguments à transmettre au programme appelé lors du démarrage du processus. Cette fonction doit être appelée avant start().

Voir aussi start(), setProgram() et arguments().

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

Définit la fonction modifier pour le processus enfant, pour les systèmes Unix (y compris macOS ; pour Windows, voir setCreateProcessArgumentsModifier()). La fonction contenue dans l'argument modifier sera invoquée dans le processus enfant après que fork() ou vfork() a été exécuté et que QProcess a configuré les descripteurs de fichiers standard pour le processus enfant, mais avant execve(), à l'intérieur de start().

L'exemple suivant montre comment configurer un processus enfant pour qu'il s'exécute sans privilèges :

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 fonction modificatrice rencontre une condition d'échec, elle peut utiliser failChildProcessModifier() pour signaler la situation à l'appelant QProcess. Elle peut également utiliser d'autres méthodes pour arrêter le processus, comme _exit() ou abort().

Certaines propriétés du processus enfant, telles que la fermeture de tous les descripteurs de fichiers superflus ou la déconnexion de l'ATS de contrôle, peuvent être obtenues plus facilement en utilisant setUnixProcessParameters(), qui peut détecter un échec et signaler une condition FailedToStart. Le modificateur est utile pour modifier certaines propriétés peu communes du processus enfant, telles que la configuration de descripteurs de fichiers supplémentaires. Si un modificateur de processus enfant et des paramètres de processus Unix sont définis, le modificateur est exécuté avant que ces paramètres ne soient appliqués.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi childProcessModifier(), failChildProcessModifier(), et setUnixProcessParameters().

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

Définit le modifier pour l'appel de l'API Win32 CreateProcess. Passez QProcess::CreateProcessArgumentModifier() pour supprimer celui qui a été défini précédemment.

Voir également createProcessArgumentsModifier(), QProcess::CreateProcessArgumentModifier, et setChildProcessModifier().

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

Définit le mode du canal d'entrée standard de QProcess à mode. Ce mode sera utilisé la prochaine fois que start() sera appelé.

Voir aussi inputChannelMode() et InputChannelMode.

void QProcess::setNativeArguments(const QString &arguments)

Définit une ligne de commande native supplémentaire arguments pour le programme.

Sur les systèmes d'exploitation où l'API du système pour transmettre la ligne de commande arguments à un sous-processus utilise nativement une chaîne unique, on peut concevoir des lignes de commande qui ne peuvent pas être transmises via l'API de QProcess basée sur une liste portable. Dans ce cas, cette fonction doit être utilisée pour définir une chaîne qui est ajoutée à la chaîne composée à partir de la liste d'arguments habituelle, avec un espace de délimitation.

Voir également nativeArguments().

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

Définit le mode des canaux de sortie standard et d'erreur standard de QProcess sur le mode mode spécifié. Ce mode sera utilisé lors du prochain appel à start(). Par exemple :

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

Voir aussi processChannelMode(), ProcessChannelMode, et setReadChannel().

void QProcess::setProcessEnvironment(const QProcessEnvironment &environment)

Définit la variable environment que QProcess transmettra au processus enfant.

Par exemple, le code suivant ajoute la variable d'environnement TMPDIR:

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

Notez que, sous Windows, les noms des variables d'environnement ne sont pas sensibles à la casse.

Voir également processEnvironment(), QProcessEnvironment::systemEnvironment() et Environment variables.

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

Définit l'état actuel du site QProcess en fonction du site state spécifié.

Voir aussi state().

void QProcess::setProgram(const QString &program)

Définit le program à utiliser lors du démarrage du processus. Cette fonction doit être appelée avant start().

Si program est un chemin absolu, il spécifie l'exécutable exact qui sera lancé. Les chemins relatifs seront résolus d'une manière spécifique à la plate-forme, ce qui inclut la recherche de la variable d'environnement PATH (voir Finding the Executable pour plus de détails).

Voir également start(), setArguments(), program() et QStandardPaths::findExecutable().

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

Définit le canal de lecture actuel de l'adresse QProcess à l'adresse channel. Le canal d'entrée actuel est utilisé par les fonctions read(), readAll(), readLine() et getChar(). Il détermine également le canal qui déclenche l'émission de readyRead() par QProcess.

Voir également readChannel().

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

Redirige l'erreur standard du processus vers le fichier fileName. Lorsque la redirection est en place, le canal de lecture de l'erreur standard est fermé : la lecture à partir de ce canal à l'aide de read() échouera toujours, tout comme readAllStandardError(). Le fichier sera ajouté si mode est Append, sinon il sera tronqué.

Voir setStandardOutputFile() pour plus d'informations sur la façon dont le fichier est ouvert.

Remarque : si setProcessChannelMode() a été appelé avec un argument QProcess::MergedChannels, cette fonction n'a aucun effet.

Voir aussi setStandardInputFile(), setStandardOutputFile() et setStandardOutputProcess().

void QProcess::setStandardInputFile(const QString &fileName)

Redirige l'entrée standard du processus vers le fichier indiqué par fileName. Lorsqu'une redirection d'entrée est en place, l'objet QProcess sera en mode lecture seule (appeler write() entraînera une erreur).

Pour que le processus lise immédiatement EOF, passez nullDevice() ici. Cette méthode est plus propre que l'utilisation de closeWriteChannel() avant d'écrire des données, car elle peut être mise en place avant le lancement du processus.

Si le fichier fileName n'existe pas au moment où start() est appelé ou n'est pas lisible, le lancement du processus échouera.

L'appel à setStandardInputFile() après le démarrage du processus n'a aucun effet.

Voir aussi setStandardOutputFile(), setStandardErrorFile() et setStandardOutputProcess().

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

Redirige la sortie standard du processus vers le fichier fileName. Lorsque la redirection est en place, le canal de lecture de la sortie standard est fermé : la lecture à partir de ce canal à l'aide de read() échouera toujours, tout comme readAllStandardOutput().

Pour rejeter toute la sortie standard du processus, passez nullDevice() ici. C'est plus efficace que de ne jamais lire la sortie standard, car aucun tampon QProcess n'est rempli.

Si le fichier fileName n'existe pas au moment où start() est appelé, il sera créé. S'il ne peut pas être créé, le démarrage échouera.

Si le fichier existe et que mode est QIODeviceBase::Truncate, le fichier sera tronqué. Sinon (si mode est QIODeviceBase::Append), le fichier sera complété.

L'appel à setStandardOutputFile() après le démarrage du processus n'a aucun effet.

Si fileName est une chaîne vide, la redirection de la sortie standard s'arrête. Ceci est utile pour restaurer la sortie standard après une redirection.

Voir aussi setStandardInputFile(), setStandardErrorFile() et setStandardOutputProcess().

void QProcess::setStandardOutputProcess(QProcess *destination)

Dirige le flux de sortie standard de ce processus vers l'entrée standard du processus destination.

La commande shell suivante :

command1 | command2

peut être exécutée à l'aide de QProcess avec le code suivant :

QProcess process1;
QProcess process2;

process1.setStandardOutputProcess(&process2);

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

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

Définit les paramètres supplémentaires du processus enfant sur les systèmes Unix à params. Cette fonction peut être utilisée pour demander à QProcess de modifier le processus enfant avant de lancer l'exécutable cible.

Cette fonction peut être utilisée pour modifier certaines propriétés du processus enfant, telles que la fermeture de tous les descripteurs de fichiers superflus, la modification du niveau de confort du processus enfant ou la déconnexion de l'ATS de contrôle. Pour un contrôle plus fin du processus enfant ou pour le modifier d'une autre manière, utilisez la fonction setChildProcessModifier(). Si un modificateur de processus enfant et des paramètres de processus Unix sont définis, le modificateur est exécuté avant que ces paramètres ne soient appliqués.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi unixProcessParameters() et setChildProcessModifier().

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

Définit les paramètres supplémentaires pour le processus enfant sur les systèmes Unix à flagsOnly. C'est la même chose que la surcharge avec seulement le champ flags défini.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi unixProcessParameters() et setChildProcessModifier().

void QProcess::setWorkingDirectory(const QString &dir)

Définit le répertoire de travail à dir. QProcess démarrera le processus dans ce répertoire. Par défaut, le processus est lancé dans le répertoire de travail du processus appelant.

Voir également workingDirectory() et start().

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

Divise la chaîne command en une liste de jetons et renvoie la liste.

Les mots-clés contenant des espaces peuvent être entourés de guillemets doubles ; trois guillemets doubles consécutifs représentent le caractère de guillemet lui-même.

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

Démarre l'application program dans un nouveau processus, en transmettant les arguments de la ligne de commande à arguments. Voir setProgram() pour des informations sur la manière dont QProcess recherche l'exécutable à exécuter. Le mode d'ouverture (OpenMode) est défini sur mode. Aucun autre découpage des arguments n'est effectué.

L'objet QProcess entre immédiatement dans l'état Starting (Démarrage). Si le processus démarre avec succès, QProcess émettra started() ; sinon, errorOccurred() sera émis. Notez que sur les plateformes capables de démarrer des processus enfants de manière synchrone (notamment Windows), ces signaux seront émis avant le retour de cette fonction et l'objet QProcess passera à l'état QProcess::Running ou QProcess::NotRunning, respectivement. Sur les autres plateformes, les signaux started() et errorOccurred() seront retardés.

Appelez waitForStarted() pour vous assurer que le processus a démarré (ou n'a pas démarré) et que ces signaux ont été émis. Il est prudent d'appeler cette fonction même si l'état de démarrage du processus est déjà connu, bien que le signal ne soit pas émis à nouveau.

Windows : Les arguments sont cités et réunis dans une ligne de commande compatible avec la fonction Windows CommandLineToArgvW(). Pour les programmes dont les exigences en matière de citation de la ligne de commande sont différentes, vous devez utiliser setNativeArguments(). Un programme notable qui ne suit pas les règles de CommandLineToArgvW() est cmd.exe et, par conséquent, tous les scripts batch.

Si l'objet QProcess exécute déjà un processus, un avertissement peut être affiché sur la console, mais le processus existant continuera à s'exécuter sans être affecté.

Voir également processId(), started(), waitForStarted() et setNativeArguments().

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

Démarre le programme défini par setProgram() avec les arguments définis par setArguments(). Le mode d'ouverture (OpenMode) est défini sur mode.

Voir aussi open(), setProgram() et setArguments().

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

Lance la commande command dans un nouveau processus. Le mode d'ouverture est défini sur mode.

command est une chaîne de texte unique contenant à la fois le nom du programme et ses arguments. Les arguments sont séparés par un ou plusieurs espaces. Les arguments sont séparés par un ou plusieurs espaces :

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

Les arguments contenant des espaces doivent être mis entre guillemets pour être correctement fournis au nouveau processus. Par exemple, les guillemets littéraux dans la chaîne doivent être mis entre guillemets :

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

Les guillemets littéraux dans la chaîne command sont représentés par des triples guillemets. Par exemple : Les guillemets littéraux dans la chaîne sont représentés par des guillemets triples :

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

Une fois que la chaîne command a été divisée et mise hors guillemets, cette fonction se comporte comme start().

Sur les systèmes d'exploitation où l'API du système pour passer des arguments de ligne de commande à un sous-processus utilise nativement une chaîne unique (Windows), il est possible de concevoir des lignes de commande qui ne peuvent pas être passées via l'API portable basée sur les listes de QProcess. Dans ces rares cas, vous devez utiliser setProgram() et setNativeArguments() au lieu de cette fonction.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi splitCommand() et start().

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

Démarre le programme défini par setProgram() avec les arguments définis par setArguments() dans un nouveau processus, et s'en détache. Renvoie true en cas de succès, sinon false. Si le processus appelant se termine, le processus détaché continuera à fonctionner sans être affecté.

Unix : Le processus démarré s'exécute dans sa propre session et agit comme un démon.

Le processus est lancé dans le répertoire défini par setWorkingDirectory(). Si workingDirectory() est vide, le répertoire de travail est hérité du processus appelant.

Si la fonction réussit, *pid reçoit l'identifiant du processus démarré ; sinon, il reçoit la valeur -1. Notez que le processus enfant peut se terminer et que le PID peut devenir invalide sans préavis. De plus, après la sortie du processus enfant, le même PID peut être recyclé et utilisé par un processus complètement différent. Le code utilisateur doit être prudent lors de l'utilisation de cette variable, en particulier si l'on a l'intention de mettre fin de force au processus par le biais du système d'exploitation.

Seuls les paramètres de propriété suivants sont pris en charge par startDetached() :

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

Toutes les autres propriétés de l'objet QProcess sont ignorées.

Voir aussi start() et 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)

Démarre le programme program avec les arguments arguments dans un nouveau processus et s'en détache. Renvoie true en cas de succès ; sinon, il renvoie false. Si le processus appelant se termine, le processus détaché continuera à fonctionner sans être affecté.

La gestion des arguments est identique à la surcharge start() correspondante.

Le processus sera lancé dans le répertoire workingDirectory. Si workingDirectory est vide, le répertoire de travail est hérité du processus appelant.

Si la fonction réussit, *pid est défini comme l'identifiant du processus démarré.

Voir aussi start().

[private signal] void QProcess::started()

Ce signal est émis par QProcess lorsque le processus a démarré, et state() renvoie Running.

QProcess::ProcessState QProcess::state() const

Renvoie l'état actuel du processus.

Voir aussi stateChanged() et error().

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

Ce signal est émis lorsque l'état de QProcess change. L'argument newState est l'état dans lequel QProcess a changé.

[static] QStringList QProcess::systemEnvironment()

Renvoie l'environnement du processus appelant sous la forme d'une liste de paires clé-valeur. Exemple :

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

Cette fonction ne met pas en cache l'environnement du système. Il est donc possible d'obtenir une version actualisée de l'environnement si des fonctions de bas niveau de la bibliothèque C telles que setenv ou putenv ont été appelées.

Notez toutefois que des appels répétés à cette fonction recréeront la liste des variables d'environnement, ce qui est une opération non triviale.

Voir aussi QProcessEnvironment::systemEnvironment() et setProcessEnvironment().

[slot] void QProcess::terminate()

Tente de mettre fin au processus.

Le processus peut ne pas se terminer à la suite de l'appel de cette fonction (il a la possibilité de demander à l'utilisateur s'il a des fichiers non sauvegardés, etc.)

Sous Windows, terminate() envoie un message WM_CLOSE à toutes les fenêtres de premier niveau du processus, puis au fil principal du processus lui-même. Sous Unix et macOS, le signal SIGTERM est envoyé.

Les applications console sous Windows qui n'exécutent pas de boucle d'événements, ou dont la boucle d'événements ne gère pas le message WM_CLOSE, ne peuvent être terminées qu'en appelant kill().

Voir également kill().

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

Renvoie l'objet UnixProcessParameters décrivant les drapeaux et paramètres supplémentaires qui seront appliqués au processus enfant sur les systèmes Unix. Les paramètres par défaut correspondent à une construction par défaut de UnixProcessParameters.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi setUnixProcessParameters() et childProcessModifier().

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

Réimplémente : QIODevice::waitForBytesWritten(int msecs).

bool QProcess::waitForFinished(int msecs = 30000)

Bloque jusqu'à ce que le processus soit terminé et que le signal finished() ait été émis, ou jusqu'à ce que msecs millisecondes se soient écoulées.

Renvoie true si le processus s'est terminé ; sinon, il renvoie false (si l'opération a dépassé le temps imparti, si une erreur s'est produite ou si ce QProcess est déjà terminé).

Cette fonction peut fonctionner sans boucle d'événements. Elle est utile lors de l'écriture d'applications non-GUI et lors de l'exécution d'opérations d'E/S dans un thread non-GUI.

Si msecs vaut -1, cette fonction n'est pas interrompue.

Voir aussi finished(), waitForStarted(), waitForReadyRead() et waitForBytesWritten().

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

Réimplémente : QIODevice::waitForReadyRead(int msecs).

bool QProcess::waitForStarted(int msecs = 30000)

Bloque jusqu'à ce que le processus ait démarré et que le signal started() ait été émis, ou jusqu'à ce que msecs millisecondes se soient écoulées.

Renvoie true si le processus a été lancé avec succès ; sinon, il renvoie false (si l'opération a dépassé le temps imparti ou si une erreur s'est produite). Si le processus a déjà été lancé avec succès avant l'exécution de cette fonction, il est renvoyé immédiatement.

Cette fonction peut fonctionner sans boucle d'événements. Elle est utile lors de l'écriture d'applications non-GUI et lors de l'exécution d'opérations d'E/S dans un thread non-GUI.

Si msecs vaut -1, cette fonction n'est pas interrompue.

Voir aussi started(), waitForReadyRead(), waitForBytesWritten() et waitForFinished().

QString QProcess::workingDirectory() const

Si un répertoire de travail a été attribué à QProcess, cette fonction renvoie le répertoire de travail dans lequel QProcess entrera avant que le programme ne démarre. Dans le cas contraire (c'est-à-dire si aucun répertoire n'a été attribué), une chaîne vide est renvoyée et QProcess utilisera le répertoire de travail actuel de l'application à la place.

Voir aussi setWorkingDirectory().