QProcess Class

Documentation des fonctions membres

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

Crée un objet QProcess avec l'parent on fournie.

[virtual noexcept] QProcess::~QProcess()

Détruit l'objet ` QProcess `, c'est-à-dire qu'il met fin au processus.

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

QStringList QProcess::arguments() const

Renvoie les arguments de ligne de commande utilisés lors du dernier démarrage du processus.

Voir également 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 de modification précédemment définie via l'appel à ` setChildProcessModifier()`.

Cette fonction a été introduite dans Qt 6.0.

Voir également setChildProcessModifier() et unixProcessParameters().

[override virtual] void QProcess::close()

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

Interrompt toute communication avec le processus et le force à s'arrêter. Après l'appel de cette fonction, QProcess n'émettra plus d'readyRead(), et il ne sera plus possible de lire ou d'écrire des données.

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

Ferme le canal de lecture channel. Une fois cette fonction appelée, QProcess ne recevra plus de données sur ce canal. Les données déjà reçues restent toutefois disponibles pour lecture.

Appelez cette fonction pour économiser de la mémoire si la sortie du processus ne vous intéresse pas.

Voir également closeWriteChannel() et setReadChannel().

void QProcess::closeWriteChannel()

Prévoit la fermeture du canal d'écriture de l'QProcess. Le canal se fermera 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 des 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. Cependant, 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 ouvert implicitement lors de l’appel de la fonction start().

Voir également closeReadChannel().

QProcess::CreateProcessArgumentModifier QProcess::createProcessArgumentsModifier() const

Renvoie une fonction de modification « CreateProcess » précédemment définie.

Voir également setCreateProcessArgumentsModifier() et QProcess::CreateProcessArgumentModifier.

QProcess::ProcessError QProcess::error() const

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

Voir également state().

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

Ce signal est émis lorsqu'une erreur survient au cours du processus. L'error, indiqué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 à celle de la surcharge correspondante de la fonction start().

Si le processus ne peut pas être lancé, la valeur -2 est renvoyée. Si le processus plante, la valeur -1 est renvoyée. 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 valide que si la fonction ` exitStatus()` renvoie ` NormalExit`.

QProcess::ExitStatus QProcess::exitStatus() const

Renvoie le code de sortie du dernier processus à s'être terminé.

Sous Windows, si le processus a été interrompu à l'aide de la fonction `TerminateProcess()` depuis une autre application, cette fonction renverra tout de même la valeur ` 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 au sein du jeu de modificateurs avec ` setChildProcessModifier()` pour signaler qu’une erreur s’est produite. Lorsque le modificateur appelle ces fonctions, ` QProcess ` émettra ` errorOccurred()` avec le code ` QProcess::FailedToStart ` dans le processus parent. La fonction ` description ` peut être utilisée pour inclure des informations dans ` errorString()` afin de faciliter le diagnostic du problème, généralement le nom de l’appel qui a échoué, à l’instar de la fonction de la bibliothèque C ` perror()`. De plus, le paramètre ` error ` peut être un code d’erreur ` <errno.h> ` dont le texte sera également inclus.

Par exemple, un modificateur de processus fils pourrait préparer un descripteur de fichier supplémentaire pour le processus fils de la manière suivante :

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 d’ EBADF, le processus ` errorString()` pourrait afficher : « Erreur signalée par le modificateur du processus enfant : canal de communication aux : descripteur de fichier incorrect ».

Cette fonction ne revient pas à l’appelant. Son utilisation en dehors du modificateur enfant et sans l’objet QProcess correct entraîne 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 s'arrête. exitCode correspond au code de sortie du processus (valable uniquement pour les sorties normales), et exitStatus correspond à l'état de sortie. Une fois le processus terminé, les tampons indiqués dans QProcess restent intacts. Vous pouvez toujours lire les données que le processus a pu écrire avant de s'arrêter.

Voir également exitStatus().

QProcess::InputChannelMode QProcess::inputChannelMode() const

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

Voir également setInputChannelMode() et InputChannelMode.

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

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

[slot] void QProcess::kill()

Tue le processus en cours, ce qui provoque sa fermeture immédiate.

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

Voir aussi ` terminate()`.

QString QProcess::nativeArguments() const

Renvoie les arguments de ligne de commande natifs supplémentaires du programme.

Voir aussi setNativeArguments().

[static] QString QProcess::nullDevice()

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

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

Voir également QProcess::setStandardInputFile(), QProcess::setStandardOutputFile() et QProcess::setStandardErrorFile().

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

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

Lance le programme défini par setProgram() avec les arguments définis par setArguments(). Le paramètre OpenMode est défini sur mode.

Cette méthode est un alias de start() et n’existe que pour implémenter intégralement l’interface définie par QIODevice.

Renvoie ` true ` si le programme a été lancé.

Voir également start(), setProgram() et setArguments().

QProcess::ProcessChannelMode QProcess::processChannelMode() const

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

Voir également 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 processus parent.

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

qint64 QProcess::processId() const

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

QString QProcess::program() const

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

Voir également setProgram() et start().

QByteArray QProcess::readAllStandardError()

Quel que soit le canal de lecture actuel, cette fonction renvoie toutes les données disponibles provenant de l'erreur standard du processus sous la forme d'un objet ` QByteArray`.

Voir également readyReadStandardError(), readAllStandardOutput(), readChannel() et setReadChannel().

QByteArray QProcess::readAllStandardOutput()

Quel que soit le canal de lecture actuel, cette fonction renvoie toutes les données disponibles sur la sortie standard du processus sous la forme d’un objet ` QByteArray`.

Voir également readyReadStandardOutput(), readAllStandardError(), readChannel() et setReadChannel().

QProcess::ProcessChannel QProcess::readChannel() const

Renvoie le canal de lecture actuel de l'QProcess.

Voir également 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 à disposition de nouvelles données via son canal d'erreur standard (stderr). Il est émis quelle que soit l'read channel.

Voir également readAllStandardError() et readChannel().

[private signal] void QProcess::readyReadStandardOutput()

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

Voir également readAllStandardOutput() et readChannel().

void QProcess::setArguments(const QStringList &arguments)

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

Voir également start(), setProgram() et arguments().

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

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

Voici un exemple de configuration d’un processus fils 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 de modification rencontre une condition d’échec, elle peut utiliser ` failChildProcessModifier()` pour signaler la situation à l’appelant de ` QProcess `. Elle peut également utiliser d’autres méthodes pour arrêter le processus, telles que ` _exit()` ou ` abort()`.

Certaines propriétés du processus fils, telles que la fermeture de tous les descripteurs de fichiers superflus ou la déconnexion du TTY de contrôle, peuvent être plus facilement mises en œuvre à l’aide de la fonction setUnixProcessParameters(), qui permet de détecter les échecs et de signaler une condition d’ FailedToStart. Le modificateur est utile pour modifier certaines propriétés peu courantes du processus fils, telles que la configuration de descripteurs de fichiers supplémentaires. Si un modificateur de processus fils et des paramètres de processus Unix sont tous deux 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 également childProcessModifier(), failChildProcessModifier() et setUnixProcessParameters().

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

Définit l'modifier e pour l'appel d'API Win32 CreateProcess. Passez QProcess::CreateProcessArgumentModifier() pour supprimer une valeur précédemment définie.

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

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

Définit le mode du canal d'entrée standard de la fonction ` QProcess ` sur la valeur spécifiée par ` mode `. Ce mode sera utilisé lors du prochain appel à la fonction ` start()`.

Voir également inputChannelMode() et InputChannelMode.

void QProcess::setNativeArguments(const QString &arguments)

Définit des arguments s supplémentaires de ligne de commande natives pour le programme.

Sur les systèmes d'exploitation où l'API système permettant de transmettre des arguments s de ligne de commande à un sous-processus utilise nativement une seule chaîne de caractères, il est possible de concevoir des lignes de commande qui ne peuvent pas être transmises via l'API portable basée sur des listes de ` QProcess`. Dans de tels cas, cette fonction doit être utilisée pour définir une chaîne de caractères qui est ajoutée à la chaîne composée à partir de la liste d'arguments habituelle, en la séparant par un espace.

Voir également nativeArguments().

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

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

QProcess builder;
builder.setProcessChannelMode(QProcess::MergedChannels);
builder.start("make", QStringList() << "-j2");

if (!builder.waitForFinished())
    qDebug() << "Make failed:" << builder.errorString();
sinon
    qDebug() << "Make output:" << builder.readAll();

Voir également processChannelMode(), ProcessChannelMode et setReadChannel().

void QProcess::setProcessEnvironment(const QProcessEnvironment &environment)

Définit la variable d'environnement « environment » que la fonction ` QProcess ` transmettra au processus fils.

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 de l'QProcess sur la valeur state spécifiée.

Voir également state().

void QProcess::setProgram(const QString &program)

Définit l'program à utiliser lors du lancement 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 selon les spécificités de la plate-forme, ce qui inclut la recherche dans 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'QProcess sur le canal spécifié channel. Le canal d'entrée actuel est utilisé par les fonctions read(), readAll(), readLine() et getChar(). Il détermine également quel canal déclenche l'QProcess pour émettre readyRead().

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 active, le canal de lecture de l'erreur standard est fermé : toute tentative de lecture à l'aide de read() échouera systématiquement, tout comme readAllStandardError(). Le fichier sera mis en append si mode est défini sur Append ; dans le cas contraire, il sera tronqué.

Voir setStandardOutputFile() pour plus d’informations sur la manière dont le fichier est ouvert.

Remarque : si la fonction setProcessChannelMode() a été appelée avec l’argument QProcess::MergedChannels, cette fonction n’a aucun effet.

Voir également 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 (l'appel de la fonction write() provoquera une erreur).

Pour que le processus lise immédiatement la fin de fichier (EOF), passez nullDevice() ici. Cette méthode est plus propre que d’utiliser closeWriteChannel() avant d’écrire des données, car elle peut être configurée avant le démarrage du processus.

Si le fichier fileName n’existe pas au moment où start() est appelé ou s’il n’est pas accessible en lecture, le lancement du processus échouera.

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

Voir également setStandardOutputFile(), setStandardErrorFile() et setStandardOutputProcess().

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

Redirige la sortie standard du processus vers le fichier fileName. Une fois la redirection mise en place, le canal de lecture de la sortie standard est fermé : toute tentative de lecture à l'aide de read() échouera systématiquement, tout comme readAllStandardOutput().

Pour ignorer toute la sortie standard du processus, passez ici nullDevice(). Cette méthode est plus efficace que de simplement 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é. Dans le cas contraire (si mode est QIODeviceBase::Append), le contenu sera ajouté à la fin du fichier.

L’appel de la fonction 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 est désactivée. Cela est utile pour rétablir la sortie standard après une redirection.

Voir également setStandardInputFile(), setStandardErrorFile() et setStandardOutputProcess().

void QProcess::setStandardOutputProcess(QProcess *destination)

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

La commande shell suivante :

command1 | command2

peut être réalisée avec ` QProcess ` à l'aide du 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 et options supplémentaires du processus fils sur les systèmes Unix à la valeur « params ». Cette fonction peut être utilisée pour demander à « QProcess » de modifier le processus fils avant de lancer l'exécutable cible.

Cette fonction permet de modifier certaines propriétés du processus fils, telles que la fermeture de tous les descripteurs de fichiers superflus, la modification du niveau de priorité (nice) du processus fils ou la déconnexion du TTY de contrôle. Pour un contrôle plus fin du processus fils ou pour le modifier d’autres façons, utilisez la fonction ` setChildProcessModifier()`. Si un modificateur de processus fils et des paramètres de processus Unix sont tous deux définis, le modificateur est exécuté avant l’application de ces paramètres.

Cette fonction a été introduite dans Qt 6.6.

Voir également ` unixProcessParameters()` et ` setChildProcessModifier()`.

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

Définit les paramètres supplémentaires du processus fils sur les systèmes Unix à « flagsOnly ». Cela revient à la surcharge où seul le champ « flags » est défini.

Cette fonction a été introduite dans Qt 6.6.

Voir également ` unixProcessParameters()` et ` setChildProcessModifier()`.

void QProcess::setWorkingDirectory(const QString &dir)

Définit le répertoire de travail sur dir. La commande « QProcess » lancera 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 tokens et renvoie cette liste.

Les tokens contenant des espaces peuvent être placés entre guillemets doubles ; trois guillemets doubles consécutifs représentent le caractère « guillemet » lui-même.

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

Lance l’ program spécifié dans un nouveau processus, en lui transmettant les arguments de ligne de commande contenus dans ` arguments`. Voir ` setProgram()` pour plus d’informations sur la manière dont ` QProcess ` recherche l’exécutable à lancer. Le paramètre `OpenMode` est défini sur ` mode`. Aucun autre fractionnement des arguments n’est effectué.

L’objet ` QProcess ` passe immédiatement à l’état `Starting`. Si le processus démarre correctement, ` QProcess ` émet ` started()` ; dans le cas contraire, ` errorOccurred()` est émis. Notez que sur les plateformes capables de lancer des processus fils de manière synchrone (notamment Windows), ces signaux seront émis avant que cette fonction ne revienne et cet objet ` QProcess ` passera respectivement à l’état ` QProcess::Running ` ou ` QProcess::NotRunning `. Sur les autres plateformes, les signaux « started » () et « errorOccurred » () seront différés.

Appelez la fonction ` waitForStarted()` pour vous assurer que le processus a démarré (ou que son démarrage a échoué) et que ces signaux ont bien été émis. Vous pouvez appeler cette fonction en toute sécurité même si l'état de démarrage du processus est déjà connu, bien que le signal ne soit pas émis une nouvelle fois.

Windows : les arguments sont placés entre guillemets et concaténés en une ligne de commande compatible avec la fonction Windows ` CommandLineToArgvW() `. Pour les programmes ayant des exigences différentes en matière de mise entre guillemets de la ligne de commande, vous devez utiliser ` setNativeArguments()`. Un programme notable qui ne respecte 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 s’afficher sur la console, et le processus existant continuera à s’exécuter sans être affecté.

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

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

Lance le programme défini par ` setProgram()` avec les arguments définis par ` setArguments()`. Le paramètre `OpenMode` est défini sur ` mode`.

Voir également 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 paramètre OpenMode est défini sur « mode ».

command Il s'agit d'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. Par exemple :

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

Les arguments contenant des espaces doivent être placés entre guillemets pour être correctement transmis au nouveau processus. Par exemple :

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 :

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

Une fois la chaîne « command » fractionnée et débarrassée de ses guillemets, cette fonction se comporte comme la fonction « start() ».

Sur les systèmes d'exploitation où l'API système permettant de transmettre des arguments de ligne de commande à un sous-processus utilise nativement une seule chaîne de caractères (Windows), il est possible de concevoir des lignes de commande qui ne peuvent pas être transmises via l'API portable basée sur une liste de la fonction QProcess. Dans ces rares cas, vous devez utiliser les fonctions setProgram() et setNativeArguments() à la place de cette fonction.

Cette fonction a été introduite dans Qt 6.0.

Voir également splitCommand() et start().

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

Lance le programme défini par ` setProgram()` avec les arguments définis par ` setArguments()` dans un nouveau processus, puis se détache de celui-ci. Renvoie ` true ` en cas de succès ; sinon, renvoie ` false`. Si le processus appelant se termine, le processus détaché continuera à s'exécuter sans être affecté.

Unix : Le processus lancé s’exécutera dans sa propre session et se comportera comme un démon.

Le processus sera 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 aboutit, *pid est défini sur l’identifiant du processus lancé ; dans le cas contraire, il est défini sur -1. Notez que le processus fils peut se terminer et que le PID peut devenir invalide sans préavis. De plus, une fois le processus fils terminé, le même PID peut être réutilisé par un processus totalement différent. Le code utilisateur doit faire preuve de prudence lors de l’utilisation de cette variable, en particulier si l’on a l’intention de forcer l’arrêt du processus à l’aide des moyens fournis par le système d’exploitation.

Seuls les accesseurs 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 également 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)

Lance le programme program avec les arguments arguments dans un nouveau processus, puis se détache de celui-ci. Renvoie true en cas de succès ; sinon, renvoie false. Si le processus appelant se termine, le processus détaché continuera à s'exécuter sans être affecté.

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

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 aboutit, *pid est défini sur l'identifiant du processus lancé.

Voir également start().

[private signal] void QProcess::started()

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

QProcess::ProcessState QProcess::state() const

Renvoie l'état actuel du processus.

Voir également stateChanged() et error().

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

Ce signal est émis chaque fois que l'état de « QProcess » change. L'argument « newState » correspond à l'état vers 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 système. Il est donc possible d'obtenir une version mise à jour de l'environnement si des fonctions de bibliothèque C de bas niveau 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 constitue une opération non négligeable.

Voir également QProcessEnvironment::systemEnvironment() et setProcessEnvironment().

[slot] void QProcess::terminate()

Tente de mettre fin au processus.

Le processus ne se ferme pas nécessairement à la suite de l'appel de cette fonction (il a la possibilité d'inviter l'utilisateur à enregistrer les fichiers non sauvegardés, etc.).

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

Les applications en 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 arrêtées qu’en appelant la fonction kill().

Voir également kill().

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

Renvoie l'objet ` UnixProcessParameters ` décrivant les indicateurs et paramètres supplémentaires qui seront appliqués au processus fils sur les systèmes Unix. Les paramètres par défaut correspondent à un objet ` UnixProcessParameters` créé par défaut.

Cette fonction a été introduite dans Qt 6.6.

Voir également setUnixProcessParameters() et childProcessModifier().

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

Réimplémentation de : 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, renvoie false (si l’opération a dépassé le délai d’attente, si une erreur s’est produite ou si cet QProcess est déjà terminé).

Cette fonction peut s’exécuter 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'aura pas de délai d'expiration.

Voir également finished(), waitForStarted(), waitForReadyRead() et waitForBytesWritten().

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

Réimplémentation de : 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 démarré avec succès ; sinon, renvoie false (si l'opération a dépassé le délai d'attente ou si une erreur s'est produite). Si le processus avait déjà démarré avec succès avant l'appel de cette fonction, celle-ci se termine 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 est égal à -1, cette fonction n’expire pas.

Voir également 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 l'QProcess ra avant le démarrage du programme. 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 alors le répertoire de travail actuel de l'application.

Voir également setWorkingDirectory().