QProcess Class

Dokumentation der Mitgliedsfunktionen

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

Konstruiert ein QProcess-Objekt mit der angegebenen parent.

[virtual noexcept] QProcess::~QProcess()

Zerstört das Objekt QProcess, d.h. beendet den Prozess.

Beachten Sie, dass diese Funktion nicht zurückkehrt, bevor der Prozess beendet ist.

QStringList QProcess::arguments() const

Gibt die Befehlszeilenargumente zurück, mit denen der Prozess zuletzt gestartet wurde.

Siehe auch setArguments() und start().

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

Reimplements: QIODevice::bytesToWrite() const.

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

Gibt die Modifikatorfunktion zurück, die zuvor durch den Aufruf von setChildProcessModifier() festgelegt wurde.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch setChildProcessModifier() und unixProcessParameters().

[override virtual] void QProcess::close()

Reimplements: QIODevice::close().

Schließt die gesamte Kommunikation mit dem Prozess und beendet ihn. Nach dem Aufruf dieser Funktion wird QProcess nicht mehr readyRead() ausgeben, und es können keine Daten mehr gelesen oder geschrieben werden.

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

Schließt den Lesekanal channel. Nach dem Aufruf dieser Funktion empfängt QProcess keine Daten mehr auf diesem Kanal. Alle bereits empfangenen Daten stehen weiterhin zum Lesen zur Verfügung.

Rufen Sie diese Funktion auf, um Speicher zu sparen, wenn Sie nicht an der Ausgabe des Prozesses interessiert sind.

Siehe auch closeWriteChannel() und setReadChannel().

void QProcess::closeWriteChannel()

Legt fest, dass der Schreibkanal von QProcess geschlossen werden soll. Der Kanal wird geschlossen, sobald alle Daten in den Prozess geschrieben worden sind. Nach dem Aufruf dieser Funktion schlagen alle Versuche, in den Prozess zu schreiben, fehl.

Das Schließen des Schreibkanals ist für Programme notwendig, die Eingabedaten lesen, bis der Kanal geschlossen wurde. Zum Beispiel wird das Programm "more" verwendet, um Textdaten in einer Konsole sowohl unter Unix als auch unter Windows anzuzeigen. Es zeigt die Textdaten jedoch erst an, wenn der Schreibkanal von QProcess geschlossen wurde. Beispiel:

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

Der Schreibkanal wird implizit geöffnet, wenn start() aufgerufen wird.

Siehe auch closeReadChannel().

QProcess::CreateProcessArgumentModifier QProcess::createProcessArgumentsModifier() const

Gibt eine zuvor eingestellte CreateProcess Modifikatorfunktion zurück.

Siehe auch setCreateProcessArgumentsModifier() und QProcess::CreateProcessArgumentModifier.

QProcess::ProcessError QProcess::error() const

Gibt den Typ des zuletzt aufgetretenen Fehlers zurück.

Siehe auch state().

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

Dieses Signal wird ausgegeben, wenn ein Fehler im Prozess auftritt. Die angegebene error beschreibt die Art des aufgetretenen Fehlers.

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

Startet das Programm program mit den Argumenten arguments in einem neuen Prozess, wartet auf dessen Beendigung und gibt dann den Exit-Code des Prozesses zurück. Alle Daten, die der neue Prozess auf die Konsole schreibt, werden an den aufrufenden Prozess weitergeleitet.

Die Umgebung und das Arbeitsverzeichnis werden vom aufrufenden Prozess geerbt.

Die Behandlung der Argumente ist identisch mit der entsprechenden start()-Überladung.

Wenn der Prozess nicht gestartet werden kann, wird -2 zurückgegeben. Wenn der Prozess abstürzt, wird -1 zurückgegeben. Andernfalls wird der Exit-Code des Prozesses zurückgegeben.

Siehe auch start().

int QProcess::exitCode() const

Gibt den Exit-Code des letzten beendeten Prozesses zurück.

Dieser Wert ist nur gültig, wenn exitStatus() NormalExit zurückgibt.

QProcess::ExitStatus QProcess::exitStatus() const

Gibt den Exit-Status des letzten beendeten Prozesses zurück.

Wenn der Prozess unter Windows mit TerminateProcess() aus einer anderen Anwendung beendet wurde, gibt diese Funktion dennoch NormalExit zurück, es sei denn, der Exit-Code ist kleiner als 0.

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

Diese Funktionen können innerhalb des Modifizierungssatzes mit setChildProcessModifier() verwendet werden, um anzuzeigen, dass eine Fehlerbedingung aufgetreten ist. Wenn der Modifikator diese Funktionen aufruft, sendet QProcess errorOccurred () mit dem Code QProcess::FailedToStart an den übergeordneten Prozess. description kann verwendet werden, um einige Informationen in errorString() aufzunehmen, die bei der Diagnose des Problems helfen, normalerweise den Namen des fehlgeschlagenen Aufrufs, ähnlich wie bei der C Library-Funktion perror(). Zusätzlich kann der Parameter error ein <errno.h> Fehlercode sein, dessen Textform ebenfalls aufgenommen wird.

Zum Beispiel könnte ein Child-Modifikator auf diese Weise einen zusätzlichen Dateideskriptor für den Child-Prozess vorbereiten:

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

Wobei fd ein aktuell im Elternprozess geöffneter Dateideskriptor ist. Wenn der Systemaufruf dup2() zu einer EBADF Bedingung führte, könnte der Prozess errorString() lauten: "Child process modifier reported error: aux comm channel: Schlechter Dateideskriptor".

Diese Funktion kehrt nicht zum Aufrufer zurück. Die Verwendung dieser Funktion an einem anderen Ort als im Child-Modifier und mit dem korrekten QProcess Objekt ist undefiniertes Verhalten.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch setChildProcessModifier() und setUnixProcessParameters().

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

Dieses Signal wird ausgegeben, wenn der Prozess beendet wird. exitCode ist der Exit-Code des Prozesses (nur gültig für normale Exits), und exitStatus ist der Exit-Status. Nachdem der Prozess beendet wurde, sind die Puffer in QProcess noch intakt. Sie können immer noch alle Daten lesen, die der Prozess geschrieben hat, bevor er beendet wurde.

Siehe auch exitStatus().

QProcess::InputChannelMode QProcess::inputChannelMode() const

Gibt den Kanalmodus des Standard-Eingabekanals QProcess zurück.

Siehe auch setInputChannelMode() und InputChannelMode.

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

Reimplements: QIODevice::isSequential() const.

[slot] void QProcess::kill()

Beendet den aktuellen Prozess, wodurch er sofort beendet wird.

Unter Windows verwendet kill() TerminateProcess, unter Unix und macOS wird das Signal SIGKILL an den Prozess gesendet.

Siehe auch terminate().

QString QProcess::nativeArguments() const

Gibt die zusätzlichen nativen Befehlszeilenargumente für das Programm zurück.

Siehe auch setNativeArguments().

[static] QString QProcess::nullDevice()

Das Null-Gerät des Betriebssystems.

Der zurückgegebene Dateipfad verwendet native Verzeichnistrennzeichen.

Siehe auch QProcess::setStandardInputFile(), QProcess::setStandardOutputFile(), und QProcess::setStandardErrorFile().

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

Reimplements: QIODevice::open(QIODeviceBase::OpenMode-Modus).

Startet das mit setProgram() eingestellte Programm mit den mit setArguments() eingestellten Argumenten. Der OpenMode wird auf mode gesetzt.

Diese Methode ist ein Alias für start() und existiert nur, um die durch QIODevice definierte Schnittstelle vollständig zu implementieren.

Gibt true zurück, wenn das Programm gestartet wurde.

Siehe auch start(), setProgram(), und setArguments().

QProcess::ProcessChannelMode QProcess::processChannelMode() const

Gibt den Kanalmodus der Standardausgabe- und Standardfehlerkanäle von QProcess zurück.

Siehe auch setProcessChannelMode(), ProcessChannelMode, und setReadChannel().

QProcessEnvironment QProcess::processEnvironment() const

Gibt die Umgebung zurück, die QProcess an seinen Kindprozess weitergeben wird. Wenn keine Umgebung mit setProcessEnvironment() gesetzt wurde, gibt diese Methode ein Objekt zurück, das anzeigt, dass die Umgebung vom Elternprozess geerbt wird.

Siehe auch setProcessEnvironment(), QProcessEnvironment::inheritsFromParent(), und Environment variables.

qint64 QProcess::processId() const

Gibt die systemeigene Prozesskennung für den laufenden Prozess zurück, sofern verfügbar. Wenn derzeit kein Prozess läuft, wird 0 zurückgegeben.

QString QProcess::program() const

Gibt das Programm zurück, mit dem der Prozess zuletzt gestartet wurde.

Siehe auch setProgram() und start().

QByteArray QProcess::readAllStandardError()

Unabhängig vom aktuellen Lesekanal gibt diese Funktion alle verfügbaren Daten aus dem Standardfehler des Prozesses als QByteArray zurück.

Siehe auch readyReadStandardError(), readAllStandardOutput(), readChannel(), und setReadChannel().

QByteArray QProcess::readAllStandardOutput()

Unabhängig vom aktuellen Lesekanal gibt diese Funktion alle verfügbaren Daten von der Standardausgabe des Prozesses als QByteArray zurück.

Siehe auch readyReadStandardOutput(), readAllStandardError(), readChannel(), und setReadChannel().

QProcess::ProcessChannel QProcess::readChannel() const

Gibt den aktuellen Lesekanal des QProcess zurück.

Siehe auch setReadChannel().

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

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

[private signal] void QProcess::readyReadStandardError()

Dieses Signal wird ausgegeben, wenn der Prozess neue Daten über seinen Standard-Fehlerkanal (stderr) zur Verfügung gestellt hat. Es wird unabhängig von der aktuellen read channel ausgegeben.

Siehe auch readAllStandardError() und readChannel().

[private signal] void QProcess::readyReadStandardOutput()

Dieses Signal wird ausgegeben, wenn der Prozess neue Daten über seinen Standardausgabekanal (stdout) zur Verfügung gestellt hat. Es wird unabhängig von der aktuellen read channel ausgegeben.

Siehe auch readAllStandardOutput() und readChannel().

void QProcess::setArguments(const QStringList &arguments)

Legt die arguments fest, die beim Starten des Prozesses an das aufgerufene Programm übergeben wird. Diese Funktion muss vor start() aufgerufen werden.

Siehe auch start(), setProgram(), und arguments().

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

Setzt die Funktion modifier für den Kindprozess, für Unix-Systeme (einschließlich macOS; für Windows, siehe setCreateProcessArgumentsModifier()). Die im Argument modifier enthaltene Funktion wird im Kindprozess aufgerufen, nachdem fork() oder vfork() abgeschlossen ist und QProcess die Standard-Dateideskriptoren für den Kindprozess eingerichtet hat, jedoch vor execve(), innerhalb von start().

Das folgende Beispiel zeigt, wie ein Kindprozess so eingerichtet wird, dass er ohne Privilegien läuft:

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

Wenn die Modifizierungsfunktion eine Fehlerbedingung erfährt, kann sie failChildProcessModifier() verwenden, um die Situation an den QProcess Aufrufer zu melden. Alternativ kann sie auch andere Methoden zum Anhalten des Prozesses verwenden, wie _exit() oder abort().

Bestimmte Eigenschaften des Kindprozesses, wie z. B. das Schließen aller fremden Dateideskriptoren oder das Trennen der Verbindung zum steuernden TTY, lassen sich leichter durch die Verwendung von setUnixProcessParameters() erreichen, das einen Fehler erkennen und einen FailedToStart Zustand melden kann. Der Modifikator ist nützlich, um bestimmte ungewöhnliche Eigenschaften des Kindprozesses zu ändern, wie z.B. zusätzliche Dateideskriptoren einzurichten. Wenn sowohl ein Kindprozess-Modifikator als auch Unix-Prozessparameter gesetzt sind, wird der Modifikator ausgeführt, bevor diese Parameter angewendet werden.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch childProcessModifier(), failChildProcessModifier(), und setUnixProcessParameters().

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

Setzt die modifier für den Win32-API-Aufruf CreateProcess. Übergeben Sie QProcess::CreateProcessArgumentModifier(), um einen zuvor gesetzten Wert zu entfernen.

Siehe auch createProcessArgumentsModifier(), QProcess::CreateProcessArgumentModifier, und setChildProcessModifier().

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

Setzt den Kanalmodus des Standard-Eingabekanals QProcess auf den angegebenen mode. Dieser Modus wird verwendet, wenn start() das nächste Mal aufgerufen wird.

Siehe auch inputChannelMode() und InputChannelMode.

void QProcess::setNativeArguments(const QString &arguments)

Dies ist eine überladene Funktion.

Setzt zusätzliche native Befehlszeilen arguments für das Programm.

Auf Betriebssystemen, bei denen die System-API für die Übergabe von Befehlszeilen arguments an einen Unterprozess nativ eine einzelne Zeichenkette verwendet, kann man sich Befehlszeilen vorstellen, die nicht über QProcess's portable listenbasierte API übergeben werden können. In solchen Fällen muss diese Funktion verwendet werden, um eine Zeichenkette zu setzen, die an die aus der üblichen Argumentliste zusammengesetzte Zeichenkette angehängt wird, wobei ein Leerzeichen als Begrenzung dient.

Siehe auch nativeArguments().

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

Setzt den Kanalmodus der Standardausgabe- und Standardfehlerkanäle von QProcess auf den angegebenen mode. Dieser Modus wird verwendet, wenn start() das nächste Mal aufgerufen wird. Zum Beispiel:

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

Siehe auch processChannelMode(), ProcessChannelMode, und setReadChannel().

void QProcess::setProcessEnvironment(const QProcessEnvironment &environment)

Legt die environment fest, die QProcess an den Kindprozess weitergibt.

Der folgende Code fügt zum Beispiel die Umgebungsvariable TMPDIR hinzu:

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

Beachten Sie, dass unter Windows die Groß- und Kleinschreibung bei der Benennung von Umgebungsvariablen nicht beachtet wird.

Siehe auch processEnvironment(), QProcessEnvironment::systemEnvironment(), und Environment variables.

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

Setzt den aktuellen Zustand von QProcess auf den angegebenen state.

Siehe auch state().

void QProcess::setProgram(const QString &program)

Legt die program fest, die beim Starten des Prozesses verwendet werden soll. Diese Funktion muss vor start() aufgerufen werden.

Wenn program ein absoluter Pfad ist, gibt er die genaue ausführbare Datei an, die gestartet wird. Relative Pfade werden auf plattformspezifische Weise aufgelöst, einschließlich der Suche in der Umgebungsvariablen PATH (siehe Finding the Executable für Details).

Siehe auch start(), setArguments(), program(), und QStandardPaths::findExecutable().

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

Setzt den aktuellen Lesekanal von QProcess auf den angegebenen channel. Der aktuelle Eingangskanal wird von den Funktionen read(), readAll(), readLine() und getChar() verwendet. Er bestimmt auch, welcher Kanal QProcess zur Ausgabe von readyRead() veranlasst.

Siehe auch readChannel().

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

Leitet den Standardfehler des Prozesses an die Datei fileName um. Wenn die Umleitung eingerichtet ist, wird der Standardfehler-Lesekanal geschlossen: Das Lesen aus der Datei mit read() wird immer fehlschlagen, ebenso wie readAllStandardError(). Die Datei wird angehängt, wenn mode Append ist, andernfalls wird sie abgeschnitten.

Siehe setStandardOutputFile() für weitere Informationen zum Öffnen der Datei.

Hinweis: Wenn setProcessChannelMode() mit dem Argument QProcess::MergedChannels aufgerufen wurde, hat diese Funktion keine Wirkung.

Siehe auch setStandardInputFile(), setStandardOutputFile(), und setStandardOutputProcess().

void QProcess::setStandardInputFile(const QString &fileName)

Leitet die Standardeingabe des Prozesses zu der durch fileName angegebenen Datei um. Wenn eine Eingabeumleitung vorhanden ist, befindet sich das Objekt QProcess im Nur-Lese-Modus (der Aufruf von write() führt zu einem Fehler).

Um den Prozess zu veranlassen, EOF sofort zu lesen, übergeben Sie hier nullDevice(). Dies ist sauberer als die Verwendung von closeWriteChannel() vor dem Schreiben von Daten, da es vor dem Start des Prozesses eingerichtet werden kann.

Wenn die Datei fileName zum Zeitpunkt des Aufrufs von start() nicht existiert oder nicht lesbar ist, schlägt das Starten des Prozesses fehl.

Der Aufruf von setStandardInputFile() nach dem Start des Prozesses hat keine Auswirkungen.

Siehe auch setStandardOutputFile(), setStandardErrorFile(), und setStandardOutputProcess().

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

Leitet die Standardausgabe des Prozesses in die Datei fileName um. Wenn die Umleitung eingerichtet ist, ist der Lesekanal für die Standardausgabe geschlossen: das Lesen mit read() wird immer fehlschlagen, ebenso wie readAllStandardOutput().

Um alle Standardausgaben des Prozesses zu verwerfen, übergeben Sie hier nullDevice(). Dies ist effizienter, als die Standardausgabe einfach nie zu lesen, da keine QProcess Puffer gefüllt werden.

Wenn die Datei fileName zum Zeitpunkt des Aufrufs von start() noch nicht existiert, wird sie erstellt. Wenn sie nicht erstellt werden kann, schlägt der Start fehl.

Wenn die Datei existiert und mode gleich QIODeviceBase::Truncate ist, wird die Datei abgeschnitten. Andernfalls (wenn mode gleich QIODeviceBase::Append ist), wird die Datei angehängt.

Der Aufruf von setStandardOutputFile() nach dem Start des Prozesses hat keine Auswirkungen.

Wenn fileName eine leere Zeichenkette ist, wird die Umleitung der Standardausgabe beendet. Dies ist nützlich, um die Standardausgabe nach einer Umleitung wiederherzustellen.

Siehe auch setStandardInputFile(), setStandardErrorFile(), und setStandardOutputProcess().

void QProcess::setStandardOutputProcess(QProcess *destination)

Leitet den Standardausgabestrom dieses Prozesses an die Standardeingabe des Prozesses destination weiter.

Der folgende Shell-Befehl:

command1 | command2

Kann mit QProcess mit folgendem Code ausgeführt werden:

QProcess process1;
QProcess process2;

process1.setStandardOutputProcess(&process2);

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

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

Setzt die zusätzlichen Einstellungen und Parameter für den Kindprozess auf Unix-Systemen auf params. Diese Funktion kann verwendet werden, um QProcess aufzufordern, den Kindprozess zu ändern, bevor das ausführbare Zielprogramm gestartet wird.

Diese Funktion kann verwendet werden, um bestimmte Eigenschaften des Kindprozesses zu ändern, wie z.B. das Schließen aller fremden Dateideskriptoren, das Ändern des Nice-Levels des Kindprozesses oder das Trennen der Verbindung mit dem steuernden TTY. Für eine feinere Kontrolle des Kindprozesses oder um ihn auf andere Weise zu verändern, verwenden Sie die Funktion setChildProcessModifier(). Wenn sowohl ein Kindprozessmodifikator als auch Unix-Prozessparameter gesetzt sind, wird der Modifikator ausgeführt, bevor diese Parameter angewendet werden.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch unixProcessParameters() und setChildProcessModifier().

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

Dies ist eine überladene Funktion.

Setzt die zusätzlichen Einstellungen für den Kindprozess auf Unix-Systemen auf flagsOnly. Dies ist dasselbe wie die Überladung, bei der nur das Feld flags gesetzt ist.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch unixProcessParameters() und setChildProcessModifier().

void QProcess::setWorkingDirectory(const QString &dir)

Setzt das Arbeitsverzeichnis auf dir. QProcess startet den Prozess in diesem Verzeichnis. Das Standardverhalten ist, den Prozess im Arbeitsverzeichnis des aufrufenden Prozesses zu starten.

Siehe auch workingDirectory() und start().

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

Zerlegt die Zeichenkette command in eine Liste von Token und gibt die Liste zurück.

Zeichen mit Leerzeichen können von doppelten Anführungszeichen umgeben sein; drei aufeinanderfolgende doppelte Anführungszeichen stellen das Anführungszeichen selbst dar.

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

Startet die angegebene program in einem neuen Prozess und übergibt die Befehlszeilenargumente in arguments. Siehe setProgram() für Informationen darüber, wie QProcess nach der auszuführenden Datei sucht. Der OpenMode wird auf mode gesetzt. Es wird keine weitere Aufteilung der Argumente vorgenommen.

Das Objekt QProcess geht sofort in den Zustand Starting über. Wenn der Prozess erfolgreich startet, gibt QProcess started () aus; andernfalls wird errorOccurred() ausgegeben. Beachten Sie, dass auf Plattformen, die in der Lage sind, Kindprozesse synchron zu starten (insbesondere Windows), diese Signale ausgegeben werden, bevor diese Funktion zurückkehrt, und dieses QProcess Objekt entweder in den Zustand QProcess::Running oder QProcess::NotRunning übergeht. Auf anderen Plattformen werden die Signale started() und errorOccurred() verzögert ausgegeben.

Rufen Sie waitForStarted() auf, um sicherzustellen, dass der Prozess gestartet wurde (oder nicht gestartet werden konnte) und diese Signale ausgegeben wurden. Es ist sicher, diese Funktion auch dann aufzurufen, wenn der Startzustand des Prozesses bereits bekannt ist, obwohl das Signal nicht erneut ausgegeben wird.

Fenster: Die Argumente werden in Anführungszeichen gesetzt und zu einer Befehlszeile verbunden, die mit der Windows-Funktion CommandLineToArgvW() kompatibel ist. Für Programme, die andere Anforderungen an die Anführungszeichen in der Befehlszeile haben, müssen Sie setNativeArguments() verwenden. Ein bemerkenswertes Programm, das sich nicht an die Regeln von CommandLineToArgvW() hält, ist cmd.exe und folglich auch alle Batch-Skripte.

Wenn das Objekt QProcess bereits einen Prozess ausführt, wird möglicherweise eine Warnung auf der Konsole ausgegeben, und der bestehende Prozess läuft unbeeinflusst weiter.

Siehe auch processId(), started(), waitForStarted(), und setNativeArguments().

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

Dies ist eine überladene Funktion.

Startet das mit setProgram() eingestellte Programm mit den mit setArguments() eingestellten Argumenten. Der OpenMode wird auf mode gesetzt.

Siehe auch open(), setProgram(), und setArguments().

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

Startet den Befehl command in einem neuen Prozess. Der OpenMode ist auf mode eingestellt.

command ist eine einzelne Textzeichenfolge, die sowohl den Programmnamen als auch die Argumente enthält. Die Argumente werden durch ein oder mehrere Leerzeichen getrennt. Ein Beispiel:

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

Argumente, die Leerzeichen enthalten, müssen in Anführungszeichen gesetzt werden, damit sie korrekt an den neuen Prozess übergeben werden. Ein Beispiel:

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

Wörtliche Anführungszeichen in der Zeichenfolge command werden durch dreifache Anführungszeichen dargestellt. Ein Beispiel:

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

Nachdem die Zeichenfolge command geteilt und aus den Anführungszeichen entfernt wurde, verhält sich diese Funktion wie start().

Auf Betriebssystemen, bei denen die System-API für die Übergabe von Befehlszeilenargumenten an einen Unterprozess von Haus aus eine einzelne Zeichenkette verwendet (Windows), kann es vorkommen, dass Befehlszeilen nicht über die portable listenbasierte API von QProcess übergeben werden können. In diesen seltenen Fällen müssen Sie setProgram() und setNativeArguments() anstelle dieser Funktion verwenden.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch splitCommand() und start().

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

Startet das mit setProgram() eingestellte Programm mit den mit setArguments() eingestellten Argumenten in einem neuen Prozess und trennt sich von diesem. Gibt bei Erfolg true zurück, andernfalls false. Wenn der aufrufende Prozess beendet wird, läuft der abgelöste Prozess unbeeinflusst weiter.

Unix: Der gestartete Prozess wird in seiner eigenen Sitzung ausgeführt und verhält sich wie ein Daemon.

Der Prozess wird in dem Verzeichnis gestartet, das durch setWorkingDirectory() festgelegt wurde. Wenn workingDirectory() leer ist, wird das Arbeitsverzeichnis vom aufrufenden Prozess geerbt.

Wenn die Funktion erfolgreich ist, wird *pid auf die Prozesskennung des gestarteten Prozesses gesetzt; andernfalls wird sie auf -1 gesetzt. Beachten Sie, dass der Kindprozess beendet werden kann und die PID ohne Vorankündigung ungültig werden kann. Außerdem kann nach dem Beenden des Kindprozesses dieselbe PID wiederverwendet und von einem völlig anderen Prozess verwendet werden. Benutzercode sollte bei der Verwendung dieser Variablen vorsichtig sein, insbesondere wenn man beabsichtigt, den Prozess mit Betriebssystemmitteln zu beenden.

Nur die folgenden Property Setter werden von startDetached() unterstützt:

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

Alle anderen Eigenschaften des QProcess Objekts werden ignoriert.

Siehe auch start() und 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)

Diese Funktion überlastet startDetached().

Startet das Programm program mit den Argumenten arguments in einem neuen Prozess und trennt sich von ihm. Gibt bei Erfolg true zurück, andernfalls false. Wenn der aufrufende Prozess beendet wird, läuft der abgetrennte Prozess unbeeinflusst weiter.

Die Argumentbehandlung ist identisch mit der entsprechenden start() Überladung.

Der Prozess wird in dem Verzeichnis workingDirectory gestartet. Wenn workingDirectory leer ist, wird das Arbeitsverzeichnis vom aufrufenden Prozess geerbt.

Wenn die Funktion erfolgreich ist, wird *pid auf die Prozesskennung des gestarteten Prozesses gesetzt.

Siehe auch start().

[private signal] void QProcess::started()

Dieses Signal wird von QProcess ausgegeben, wenn der Prozess gestartet ist, und state() gibt Running zurück.

QProcess::ProcessState QProcess::state() const

Gibt den aktuellen Status des Prozesses zurück.

Siehe auch stateChanged() und error().

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

Dieses Signal wird ausgegeben, wenn sich der Zustand von QProcess ändert. Das Argument newState ist der Zustand, in den QProcess gewechselt hat.

[static] QStringList QProcess::systemEnvironment()

Gibt die Umgebung des aufrufenden Prozesses als eine Liste von Schlüssel=Wert-Paaren zurück. Beispiel:

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

Diese Funktion speichert die Systemumgebung nicht im Cache. Daher ist es möglich, eine aktualisierte Version der Umgebung zu erhalten, wenn Low-Level-C-Bibliotheksfunktionen wie setenv oder putenv aufgerufen wurden.

Beachten Sie jedoch, dass bei wiederholten Aufrufen dieser Funktion die Liste der Umgebungsvariablen neu erstellt wird, was eine nicht triviale Operation ist.

Siehe auch QProcessEnvironment::systemEnvironment() und setProcessEnvironment().

[slot] void QProcess::terminate()

Versucht, den Prozess zu beenden.

Der Prozess darf durch den Aufruf dieser Funktion nicht beendet werden (er erhält die Möglichkeit, den Benutzer nach ungespeicherten Dateien usw. zu fragen).

Unter Windows sendet terminate() eine WM_CLOSE-Nachricht an alle Top-Level-Fenster des Prozesses und dann an den Hauptthread des Prozesses selbst. Unter Unix und macOS wird das Signal SIGTERM gesendet.

Konsolenanwendungen unter Windows, die keine Ereignisschleife ausführen oder deren Ereignisschleife die WM_CLOSE-Nachricht nicht verarbeitet, können nur durch den Aufruf von kill() beendet werden.

Siehe auch kill().

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

Gibt das Objekt UnixProcessParameters zurück, das zusätzliche Flags und Einstellungen beschreibt, die auf Unix-Systemen auf den Kindprozess angewendet werden. Die Standardeinstellungen entsprechen einem standardmäßig konstruierten UnixProcessParameters.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch setUnixProcessParameters() und childProcessModifier().

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

Reimplements: QIODevice::waitForBytesWritten(int msecs).

bool QProcess::waitForFinished(int msecs = 30000)

Blockiert, bis der Prozess beendet ist und das Signal finished() ausgegeben wurde, oder bis msecs Millisekunden vergangen sind.

Gibt true zurück, wenn der Prozess beendet wurde; andernfalls wird false zurückgegeben (wenn der Vorgang eine Zeitüberschreitung hatte, ein Fehler auftrat oder dieser QProcess bereits beendet ist).

Diese Funktion kann ohne eine Ereignisschleife arbeiten. Sie ist nützlich beim Schreiben von Nicht-GUI-Anwendungen und bei der Durchführung von E/A-Operationen in einem Nicht-GUI-Thread.

Wenn msecs -1 ist, wird diese Funktion nicht abgebrochen.

Siehe auch finished(), waitForStarted(), waitForReadyRead(), und waitForBytesWritten().

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

Reimplements: QIODevice::waitForReadyRead(int msecs).

bool QProcess::waitForStarted(int msecs = 30000)

Blockiert, bis der Prozess gestartet wurde und das Signal started() ausgegeben wurde oder bis msecs Millisekunden vergangen sind.

Gibt true zurück, wenn der Prozess erfolgreich gestartet wurde; andernfalls wird false zurückgegeben (wenn der Vorgang eine Zeitüberschreitung hatte oder ein Fehler auftrat). Wenn der Prozess bereits vor dieser Funktion erfolgreich gestartet wurde, kehrt sie sofort zurück.

Diese Funktion kann ohne eine Ereignisschleife arbeiten. Sie ist nützlich beim Schreiben von Nicht-GUI-Anwendungen und bei der Durchführung von E/A-Operationen in einem Nicht-GUI-Thread.

Wenn msecs -1 ist, wird diese Funktion nicht abgebrochen.

Siehe auch started(), waitForReadyRead(), waitForBytesWritten(), und waitForFinished().

QString QProcess::workingDirectory() const

Wenn QProcess ein Arbeitsverzeichnis zugewiesen wurde, gibt diese Funktion das Arbeitsverzeichnis zurück, in das QProcess vor dem Programmstart wechselt. Andernfalls (d.h. wenn kein Verzeichnis zugewiesen wurde) wird eine leere Zeichenkette zurückgegeben, und QProcess verwendet stattdessen das aktuelle Arbeitsverzeichnis der Anwendung.

Siehe auch setWorkingDirectory().