QProcess Class

Dokumentation zu den Mitgliedsfunktionen

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

Erstellt ein QProcess-Objekt mit dem angegebenen „ parent “.

[virtual noexcept] QProcess::~QProcess()

Löst das „ QProcess “-Objekt auf, d. h., beendet den Prozess.

Beachten Sie, dass diese Funktion erst dann zurückkehrt, wenn 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

Implementiert: ` QIODevice::bytesToWrite()` const.

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

Gibt die zuvor durch den Aufruf von ` setChildProcessModifier()` festgelegte Modifikatorfunktion zurück.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „ setChildProcessModifier()“ und „ unixProcessParameters()“.

[override virtual] void QProcess::close()

Implementiert: QIODevice::close().

Beendet die gesamte Kommunikation mit dem Prozess und beendet diesen. Nach dem Aufruf dieser Funktion sendet „ QProcess “ keine „ readyRead()“-Meldungen mehr aus, und es können keine Daten mehr gelesen oder geschrieben werden.

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

Schließt den Lese-Kanal „ channel “. Nach dem Aufruf dieser Funktion empfängt „ QProcess “ keine Daten mehr über diesen Kanal. Bereits empfangene Daten stehen weiterhin zum Lesen zur Verfügung.

Rufen Sie diese Funktion auf, um Speicherplatz 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 wird. Der Kanal wird geschlossen, sobald alle Daten in den Prozess geschrieben wurden. Nach dem Aufruf dieser Funktion schlagen alle Versuche, in den Prozess zu schreiben, fehl.

Das Schließen des Schreibkanals ist für Programme erforderlich, die Eingabedaten so lange lesen, bis der Kanal geschlossen wurde. Das Programm „more“ wird beispielsweise sowohl unter Unix als auch unter Windows verwendet, um Textdaten in einer Konsole 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 festgelegte Modifikatorfunktion für „ CreateProcess “ 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 beim Prozess ein Fehler auftritt. Der angegebene Fehlercode „ 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, bis es beendet ist, und gibt anschließend den Beendigungscode des Prozesses zurück. Alle Daten, die der neue Prozess in die Konsole schreibt, werden an den aufrufenden Prozess weitergeleitet.

Die Umgebungsvariablen und das Arbeitsverzeichnis werden vom aufrufenden Prozess übernommen.

Die Argumentverarbeitung entspricht der jeweiligen Überladung von ` start()`.

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

Siehe auch ` start()`.

int QProcess::exitCode() const

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

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

QProcess::ExitStatus QProcess::exitStatus() const

Gibt den Beendigungsstatus des zuletzt abgeschlossenen Prozesses zurück.

Unter Windows gibt diese Funktion auch dann „ NormalExit “ zurück, wenn der Prozess von einer anderen Anwendung mit `TerminateProcess()` beendet wurde, es sei denn, der Beendigungscode ist kleiner als 0.

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

Diese Funktionen können innerhalb des Modifikators mit „ setChildProcessModifier()“ verwendet werden, um anzuzeigen, dass ein Fehler aufgetreten ist. Wenn der Modifikator diese Funktionen aufruft, löst „ QProcess “ im übergeordneten Prozess „ errorOccurred()“ mit dem Code „ QProcess::FailedToStart “ aus. Die Funktion „ description “ kann verwendet werden, um Informationen in „ errorString()“ einzufügen, die bei der Diagnose des Problems helfen – in der Regel den Namen des fehlgeschlagenen Aufrufs, ähnlich wie bei der C-Bibliotheksfunktion „ perror() “. Zusätzlich kann der Parameter „ error “ einen „ <errno.h> “-Fehlercode sein, dessen Textform ebenfalls mitübermittelt wird.

Beispielsweise könnte ein Kind-Modifikator auf diese Weise einen zusätzlichen Dateideskriptor für den Kindprozess vorbereiten:

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

Dabei ist ` fd ` ein Dateideskriptor, der derzeit im Elternprozess geöffnet ist. Wenn der Systemaufruf ` dup2() ` zu einer ` EBADF `-Bedingung führte, könnte der Prozess ` errorString()` den Fehler „Child process modifier reported error: aux comm channel: Bad file descriptor“ melden.

Diese Funktion kehrt nicht zum Aufrufer zurück. Die Verwendung an einer anderen Stelle als im Kindprozess-Modifikator und ohne das korrekte ` QProcess `-Objekt führt zu undefiniertem 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 (gilt nur für normale Beendigungen), und exitStatus ist der Exit-Status. Nach Beendigung des Prozesses sind die Puffer unter QProcess weiterhin intakt. Sie können weiterhin alle Daten lesen, die der Prozess vor seiner Beendigung möglicherweise geschrieben hat.

Siehe auch exitStatus().

QProcess::InputChannelMode QProcess::inputChannelMode() const

Gibt den Kanalmodus des Standardeingabekanals von „ QProcess “ zurück.

Siehe auch setInputChannelMode() und InputChannelMode.

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

Implementiert: ` QIODevice::isSequential()` const.

[slot] void QProcess::kill()

Beendet den aktuellen Prozess, wodurch dieser sofort beendet wird.

Unter Windows verwendet `kill()` die Funktion `TerminateProcess`, unter Unix und macOS wird das SIGKILL-Signal 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)

Implementiert: ` QIODevice::open` (Modus `QIODeviceBase::OpenMode`).

Startet das durch ` setProgram()` festgelegte Programm mit den durch ` setArguments()` festgelegten Argumenten. Der OpenMode wird auf ` mode` gesetzt.

Diese Methode ist ein Alias für ` start()` und dient ausschließlich der vollständigen Implementierung der durch ` QIODevice` definierten Schnittstelle.

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 untergeordneten Prozess weitergibt. Wenn mit setProcessEnvironment() keine Umgebung festgelegt wurde, gibt diese Methode ein Objekt zurück, das angibt, dass die Umgebung vom übergeordneten Prozess geerbt wird.

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

qint64 QProcess::processId() const

Gibt die native Prozess-ID des laufenden Prozesses 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 Daten, die über den Standardfehler des Prozesses verfügbar sind, als „ QByteArray “ zurück.

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

QByteArray QProcess::readAllStandardOutput()

Unabhängig vom aktuellen Lesekanal gibt diese Funktion alle Daten, die über die Standardausgabe des Prozesses verfügbar sind, als „ QByteArray “ zurück.

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

QProcess::ProcessChannel QProcess::readChannel() const

Gibt den aktuell gelesenen Kanal des „ QProcess “ zurück.

Siehe auch setReadChannel().

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

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

[private signal] void QProcess::readyReadStandardError()

Dieses Signal wird ausgesendet, wenn der Prozess über seinen Standard-Fehlerkanal (stderr) neue Daten bereitgestellt hat. Es wird unabhängig vom aktuellen Status „ read channel “ ausgesendet.

Siehe auch readAllStandardError() und readChannel().

[private signal] void QProcess::readyReadStandardOutput()

Dieses Signal wird ausgesendet, wenn der Prozess über seinen Standardausgabekanal (stdout) neue Daten bereitgestellt hat. Es wird unabhängig vom aktuellen Wert von ` read channel` ausgesendet.

Siehe auch readAllStandardOutput() und readChannel().

void QProcess::setArguments(const QStringList &arguments)

Legen Sie die „ arguments “ fest, die beim Starten des Prozesses an das aufgerufene Programm übergeben werden soll. Diese Funktion muss vor „ start()“ aufgerufen werden.

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

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

Legt die Funktion ` modifier ` für den Kindprozess fest, 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 wurde und ` QProcess ` die Standard-Dateideskriptoren für den Kindprozess eingerichtet hat, jedoch vor ` execve()`, innerhalb von ` start().

Im Folgenden wird ein Beispiel für die Einrichtung eines Kindprozesses gezeigt, der ohne Privilegien ausgeführt wird:

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

Tritt bei der Modifikatorfunktion ein Fehler auf, kann sie mit ` failChildProcessModifier()` die Situation an den Aufrufer von ` QProcess ` melden. Alternativ kann sie andere Methoden zum Beenden des Prozesses verwenden, wie beispielsweise ` _exit()` oder ` abort()`.

Bestimmte Eigenschaften des Kindprozesses, wie das Schließen aller überflüssigen Dateideskriptoren oder das Trennen der Verbindung zum steuernden TTY, lassen sich leichter mit ` setUnixProcessParameters()` erreichen, da diese Funktion Fehler erkennen und einen ` FailedToStart `-Zustand melden kann. Der Modifikator ist nützlich, um bestimmte ungewöhnliche Eigenschaften des Kindprozesses zu ändern, wie zum Beispiel das Einrichten zusätzlicher Dateideskriptoren. 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)

Legt den Wert „ modifier “ für den Win32-API-Aufruf „ CreateProcess “ fest. Übergeben Sie „ QProcess::CreateProcessArgumentModifier() “, um einen zuvor festgelegten Wert zu entfernen.

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

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

Legt den Kanalmodus des Standardeingabekanals von „ QProcess “ auf den angegebenen Wert „ mode “ fest. Dieser Modus wird beim nächsten Aufruf von „ start()“ verwendet.

Siehe auch inputChannelMode() und InputChannelMode.

void QProcess::setNativeArguments(const QString &arguments)

Legt zusätzliche native Befehlszeilen arguments en für das Programm fest.

Auf Betriebssystemen, bei denen die System-API zur Übergabe von Befehlszeilen arguments en an einen Unterprozess standardmäßig eine einzelne Zeichenkette verwendet, sind Befehlszeilen denkbar, die nicht über die portable, listenbasierte API von „ QProcess “ übergeben werden können. In solchen Fällen muss diese Funktion verwendet werden, um eine Zeichenkette festzulegen, die mit einem Leerzeichen als Trennzeichen an die aus der üblichen Argumentliste zusammengesetzte Zeichenkette angehängt wird.

Siehe auch ` nativeArguments()`.

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

Legt den Kanalmodus der Standardausgabe- und Standardfehlerkanäle von ` QProcess ` auf den angegebenen Wert ` mode ` fest. Dieser Modus wird beim nächsten Aufruf von ` start()` verwendet. 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 Umgebungsvariable „ environment “ fest, die von „ QProcess “ an den untergeordneten Prozess übergeben wird.

Der folgende Code fügt beispielsweise 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 bei Windows bei den Namen von Umgebungsvariablen die Groß-/Kleinschreibung keine Rolle spielt.

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

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

Setzt den aktuellen Status des „ QProcess “ auf den angegebenen „ state “.

Siehe auch state().

void QProcess::setProgram(const QString &program)

Legen Sie die beim Starten des Prozesses zu verwendende „ program “ fest. Diese Funktion muss vor dem Aufruf von „ start()“ aufgerufen werden.

Wenn „ program “ ein absoluter Pfad ist, gibt er die genaue ausführbare Datei an, die gestartet wird. Relative Pfade werden plattformspezifisch aufgelöst, wozu auch die Suche in der Umgebungsvariablen „ PATH “ gehört (Einzelheiten finden Sie unter Finding the Executable ).

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

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

Setzt den aktuellen Lesekanal des „ QProcess “ auf den angegebenen „ channel “. Der aktuelle Eingangskanal wird von den Funktionen „ read()“, „ readAll()“, „ readLine()“ und „ getChar()“ verwendet. Er bestimmt außerdem, welcher Kanal „ QProcess “ dazu veranlasst, „ readyRead()“ auszugeben.

Siehe auch readChannel().

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

Leitet die Standardfehlerausgabe des Prozesses in die Datei „ fileName “ um. Wenn die Umleitung aktiv ist, wird der Lesekanal für die Standardfehlerausgabe geschlossen: Der Lesevorgang mit „ read()“ schlägt stets fehl, ebenso wie „ readAllStandardError()“. Die Datei wird angehängt, wenn „ mode “ auf „Append“ gesetzt ist; andernfalls wird sie gekürzt.

Weitere Informationen darüber, wie die Datei geöffnet wird, finden Sie unter setStandardOutputFile().

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

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

void QProcess::setStandardInputFile(const QString &fileName)

Leitet die Standardeingabe des Prozesses in die durch ` fileName` angegebene Datei um. Wenn eine Eingabeumleitung vorliegt, befindet sich das Objekt ` QProcess ` im schreibgeschützten Modus (der Aufruf von ` write()` führt zu einem Fehler).

Damit der Prozess sofort EOF liest, übergeben Sie hier ` nullDevice()`. Dies ist übersichtlicher als die Verwendung von ` closeWriteChannel()` vor dem Schreiben von Daten, da es bereits 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 der Start des Prozesses fehl.

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

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. Sobald die Umleitung eingerichtet ist, wird der Lesekanal für die Standardausgabe geschlossen: Der Versuch, mit „ read()“ daraus zu lesen, schlägt stets fehl, ebenso wie der Versuch mit „ readAllStandardOutput()“.

Um die gesamte Standardausgabe 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 angelegt. Kann sie nicht angelegt werden, schlägt der Start fehl.

Wenn die Datei existiert und „ mode “ auf „ QIODeviceBase::Truncate “ gesetzt ist, wird die Datei gekürzt. Andernfalls (wenn „ mode “ auf „ QIODeviceBase::Append “ gesetzt ist) wird die Datei angehängt.

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

Ist fileName eine leere Zeichenkette, 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

lässt sich mit „ QProcess “ mithilfe des folgenden Codes umsetzen:

QProcess process1;
QProcess process2;

process1.setStandardOutputProcess(&process2);

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

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

Legt die zusätzlichen Einstellungen und Parameter für den Kindprozess auf Unix-Systemen auf „ params “ fest. Mit dieser Funktion kann „ QProcess “ angewiesen werden, den Kindprozess vor dem Start der Zielausführungsdatei anzupassen.

Diese Funktion kann verwendet werden, um bestimmte Eigenschaften des Kindprozesses zu ändern, wie z. B. das Schließen aller überflüssigen Dateideskriptoren, das Ändern des „nice“-Levels des Kindprozesses oder das Trennen der Verbindung zum steuernden TTY. Für eine feinere Steuerung des Kindprozesses oder um ihn auf andere Weise zu modifizieren, verwenden Sie die Funktion ` setChildProcessModifier()`. Wenn sowohl ein Kindprozess-Modifikator als auch Unix-Prozessparameter festgelegt 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)

Legt die zusätzlichen Einstellungen für den untergeordneten Prozess auf Unix-Systemen auf „ flagsOnly “ fest. Dies entspricht der Überladung, bei der lediglich 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)

Legt das Arbeitsverzeichnis auf „ dir “ fest. Mit dem Befehl „ QProcess “ wird der Prozess in diesem Verzeichnis gestartet. Standardmäßig wird der Prozess im Arbeitsverzeichnis des aufrufenden Prozesses gestartet.

Siehe auch workingDirectory() und start().

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

Teilt die Zeichenkette „ command “ in eine Liste von Tokens auf und gibt die Liste zurück.

Token mit Leerzeichen können in doppelte Anführungszeichen gesetzt werden; drei aufeinanderfolgende doppelte Anführungszeichen stehen für das Anführungszeichen selbst.

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

Startet das angegebene „ program “ in einem neuen Prozess und übergibt dabei die Befehlszeilenargumente in „ arguments “. Informationen dazu, wie „ QProcess “ nach der auszuführenden ausführbaren Datei sucht, finden Sie unter „ setProgram()“. Der „OpenMode“ wird auf „ mode “ gesetzt. Es erfolgt keine weitere Aufteilung der Argumente.

Das ` QProcess `-Objekt wechselt sofort in den Zustand „Starting“. Wenn der Prozess erfolgreich gestartet wird, gibt ` QProcess ` das Signal ` started` () aus; andernfalls wird das Signal ` errorOccurred` () ausgegeben. Beachten Sie, dass auf Plattformen, die Kindprozesse synchron starten können (insbesondere Windows), diese Signale ausgegeben werden, bevor diese Funktion zurückkehrt, und dieses ` QProcess `-Objekt jeweils 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 der Start fehlgeschlagen ist) und diese Signale ausgesendet wurden. Es ist unbedenklich, diese Funktion aufzurufen, selbst wenn der Startstatus des Prozesses bereits bekannt ist, auch wenn das Signal in diesem Fall nicht erneut ausgesendet wird.

Windows: Die Argumente werden in Anführungszeichen gesetzt und zu einer Befehlszeile zusammengefügt, die mit der Windows-Funktion „ CommandLineToArgvW() “ kompatibel ist. Für Programme, die andere Anforderungen an die Befehlszeilen-Anführungszeichen stellen, müssen Sie „ setNativeArguments “ () verwenden. Ein bekanntes Programm, das die Regeln von „ CommandLineToArgvW() “ nicht befolgt, ist „cmd.exe“ und folglich alle Batch-Skripte.

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

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

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

Startet das mit ` setProgram()` festgelegte Programm mit den durch ` setArguments()` festgelegten 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 wird auf „ mode “ gesetzt.

command ist eine einzelne Textzeichenfolge, die sowohl den Programmnamen als auch dessen Argumente enthält. Die Argumente werden durch ein oder mehrere Leerzeichen voneinander getrennt. 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. Beispiel:

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

Literale Anführungszeichen in der Zeichenkette „ command “ werden durch dreifache Anführungszeichen dargestellt. Beispiel:

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

Nachdem die Zeichenkette „ command “ aufgeteilt und aus den Anführungszeichen entfernt wurde, verhält sich diese Funktion wie „ start()“.

Auf Betriebssystemen, bei denen die System-API zur Übergabe von Befehlszeilenargumenten an einen Unterprozess nativ eine einzelne Zeichenkette verwendet (Windows), sind Befehlszeilen denkbar, die nicht über die portable, listenbasierte API von ` QProcess` übergeben werden können. In diesen seltenen Fällen müssen Sie anstelle dieser Funktion ` setProgram()` und ` setNativeArguments()` 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()` festgelegte Programm mit den durch ` setArguments()` festgelegten Argumenten in einem neuen Prozess und trennt sich von diesem. Gibt bei Erfolg ` true ` zurück; andernfalls wird ` false` zurückgegeben. Wenn der aufrufende Prozess beendet wird, läuft der abgetrennte Prozess davon unbeeindruckt weiter.

Unix: Der gestartete Prozess läuft in einer eigenen Sitzung und verhält sich wie ein Daemon.

Der Prozess wird in dem Verzeichnis gestartet, das durch ` setWorkingDirectory()` festgelegt wurde. Ist ` workingDirectory()` leer, wird das Arbeitsverzeichnis vom aufrufenden Prozess übernommen.

Ist die Funktion erfolgreich, wird *pid auf die Prozess-ID des gestarteten Prozesses gesetzt; andernfalls wird sie auf -1 gesetzt. Beachten Sie, dass der Kindprozess beendet werden kann und die PID ohne Vorwarnung ungültig werden kann. Darüber hinaus kann dieselbe PID nach Beendigung des Kindprozesses wiederverwendet und von einem völlig anderen Prozess genutzt werden. Benutzercode sollte bei der Verwendung dieser Variablen vorsichtig sein, insbesondere wenn beabsichtigt wird, den Prozess mit Mitteln des Betriebssystems zwangsweise zu beenden.

Von startDetached() werden nur die folgenden Eigenschaftssetter unterstützt:

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

Alle anderen Eigenschaften des Objekts „ QProcess “ 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)

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

Die Argumentverarbeitung entspricht der jeweiligen Überladung von ` start()`.

Der Prozess wird im Verzeichnis „ workingDirectory “ gestartet. Ist „ workingDirectory “ leer, wird das Arbeitsverzeichnis vom aufrufenden Prozess übernommen.

Ist die Funktion erfolgreich, wird *pid auf die Prozess-ID des gestarteten Prozesses gesetzt.

Siehe auch start().

[private signal] void QProcess::started()

Dieses Signal wird von „ QProcess “ ausgesendet, wenn der Prozess gestartet wurde und „ state()“ den Wert „ Running “ zurückgibt.

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 immer dann ausgelöst, wenn sich der Zustand von „ QProcess “ ändert. Das Argument „ newState “ gibt den Zustand an, auf den „ QProcess “ geändert wurde.

[static] QStringList QProcess::systemEnvironment()

Gibt die Systemumgebung des aufrufenden Prozesses als 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 wiederholte Aufrufe dieser Funktion die Liste der Umgebungsvariablen neu erstellen, was ein nicht trivialer Vorgang ist.

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

[slot] void QProcess::terminate()

Versucht, den Prozess zu beenden.

Der Prozess wird durch den Aufruf dieser Funktion möglicherweise nicht beendet (er erhält die Möglichkeit, den Benutzer nach nicht gespeicherten Dateien usw. zu fragen).

Unter Windows sendet `terminate()` eine WM_CLOSE-Meldung an alle Fenster der obersten Ebene des Prozesses und anschließend 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-Meldung 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 untergeordneten Prozess 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)

Implementiert: QIODevice::waitForBytesWritten(int msecs).

bool QProcess::waitForFinished(int msecs = 30000)

Hält an, bis der Prozess beendet ist und das Signal ` finished()` ausgelöst wurde, oder bis ` msecs ` Millisekunden verstrichen sind.

Gibt ` true ` zurück, wenn der Vorgang abgeschlossen ist; andernfalls gibt sie ` false ` zurück (wenn das Zeitlimit abgelaufen ist, ein Fehler aufgetreten ist oder diese ` QProcess ` bereits beendet ist).

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

Ist „msecs“ gleich -1, läuft diese Funktion ohne Zeitlimit ab.

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

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

Implementiert: QIODevice::waitForReadyRead(int msecs).

bool QProcess::waitForStarted(int msecs = 30000)

Hält an, bis der Prozess gestartet wurde und das Signal „ started()“ ausgesendet wurde, oder bis msecs Millisekunden verstrichen sind.

Gibt „ true “ zurück, wenn der Prozess erfolgreich gestartet wurde; andernfalls wird „ false “ zurückgegeben (wenn das Zeitlimit abgelaufen ist oder ein Fehler aufgetreten ist). Wenn der Prozess bereits vor dem Aufruf dieser Funktion erfolgreich gestartet wurde, kehrt die Funktion sofort zurück.

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

Ist `msecs` gleich -1, läuft diese Funktion ohne Zeitlimit ab.

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

QString QProcess::workingDirectory() const

Wenn für ` QProcess ` ein Arbeitsverzeichnis zugewiesen wurde, gibt diese Funktion das Arbeitsverzeichnis zurück, in das die Funktion ` QProcess ` wechselt, bevor das Programm gestartet wird. 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()`.