So schließen Sie ein Programm in Windows:
Im Qt-Code muss qprocess manchmal ein Programm eines Drittanbieters aufrufen und nach Abschluss des Aufrufs beendet werden. Es ist nicht geeignet, es manuell herauszubekommen. Zu diesem Zeitpunkt können Sie das Taskkill-Programm unter dem Fenster aufrufen, um das Programm zu schließen.
QProcess-Prozess;
Process.execute("taskkill /im xx.exe /f");
So schließen Sie ein Programm unter Linux
Mit dem Befehl kill können Sie einen Prozess in Ubuntu beenden. Um den Kill-Befehl im Qt-Code zu verwenden, kann dies durch Erben der QProcess-Klasse erreicht werden.
Code wie folgt anzeigen:
```
#include <QtCore>
class MyProcess : public QProcess { public: void stopProcess() { if (state() != QProcess::NotRunning) { Terminate(); // SIGTERM-Signal senden waitForFinished(); // Warten, bis der Prozess beendet wird } } } ;
int main(int argc, char *argv[])
{ QCoreApplication a(argc, argv); MyProcess Process; Process.start("your_program"); // Rufen Sie das Programm auf, das beendet werden muss
Process.stopProcess(); // Programm beenden
return a.exec();
}
```
Hier wird die benutzerdefinierte MyProcess-Klasse verwendet, um QProcess zu erben, und die stopProcess()-Methode wird hinzugefügt, um die Funktion zum Beenden des Prozesses zu implementieren.
Die Methode stopProcess() sendet zunächst das SIGTERM-Signal, um den Prozess zu beenden, und wartet dann, bis der Prozess vollständig beendet ist. Wenn waitForFinished() nicht aufgerufen wird, wird der Prozess möglicherweise heruntergefahren, ohne vollständig beendet zu werden.
Verbessern Sie diesen Code weiter, kapseln Sie den Ausgabeinhalt des ausgeführten Konsolenprogramms in der MyProcess-Klasse und zeigen Sie ihn in Echtzeit-qdebug an.
Auf der Suche nach einer besseren Lösung kann ich diesen Code weiter verbessern, um den Ausgabeinhalt des ausgeführten Konsolenprogramms zu kapseln und ihn in QDebug in Echtzeit anzuzeigen.
Der geänderte Code lautet wie folgt:
```
#include <QtCore>
class MyProcess : public QProcess { public: MyProcess() { connect(this, &QProcess::readyReadStandardOutput, [=](){ QByteArray output = this->readAllStandardOutput(); //QByteArray konvertiert in QString und entfernt den nachgestellten QString-Neuzeilentext (Ausgabe); text.chop(1); qDebug() << text; }); }
void stopProcess() { if (state() != QProcess::NotRunning) { Terminate(); // SIGTERM-Signal senden waitForFinished(); // Warten, bis der Prozess beendet wird } } };
int main(int argc, char *argv[])
{ QCoreApplication a(argc, argv); MyProcess Process; Process.start("your_program"); // Rufen Sie das Programm auf, das beendet werden muss
Process.waitForFinished(); //Warten, bis die Programmausführung beendet ist
return a.exec();
}
```
Im Konstruktor der MyProcess-Klasse habe ich einen Lambda-Ausdruck hinzugefügt, der mit dem Signal „readyReadStandardOutput()“ von QProcess verbunden ist, um den vom aufrufenden Programm ausgegebenen Inhalt in Echtzeit abzurufen und ihn in Echtzeit über QDebug auszugeben.
Dann rufen wir im Programm die Methode waitForFinished() des Prozesses auf und warten, bis das Programm die Ausführung abgeschlossen hat. Während der Ausführung des Programms gibt die MyProcess-Klasse den erhaltenen Ausgabeinhalt des aufrufenden Programms an die Konsole aus.
Hinweis: Die Verwendung der Methode „waitForFinished()“ blockiert die Ausführung des Programms. Wenn eine große Menge an Ausgabeinhalten generiert wird, kann das Programm aufgrund der Blockierung möglicherweise nicht mehr reagieren. Wenn Sie Blockierungen vermeiden müssen, können Sie die Signale und Slots von QProcess verwenden.
In diesem Beispiel wird qDebug() << text; nach stopProcess() ausgeführt. Process.waitForFinished(); wartet auf das Ende der Programmausführung, bevor es ausgedruckt wird. Gibt es eine Möglichkeit, die Echtzeit-Ausgabeinformationen des ausgeführten Programms in Echtzeit auszugeben?
Dieses Problem liegt daran, dass „qDebug() << text“ eine asynchrone Operation in der Signal-Slot-Funktion in der MyProcess-Klasse verwendet. Das heißt, wenn die Programmausgabe erhalten wird, wird eine Signalbenachrichtigung zur Ausgabe an den Hauptthread gesendet. Möglicherweise Befindet sich immer noch im Hauptthread. Warten Sie, bis das Programm ausgeführt wird. Daher muss vor der Ausgabe gewartet werden, bis das Programm ausgeführt wird.
Um eine Echtzeitausgabe der Ausgabeinformationen des ausführenden Programms zu realisieren, müssen wir die Ausgabe von „qDebug() << text“ zur Ausführung in den Hauptprozess verschieben. Die spezifische Implementierung kann darin bestehen, eine Schleife im Hauptprozess einzurichten, um den in der MyProcess-Klasse gespeicherten Ausgabecache in Echtzeit zu lesen und an die Konsole auszugeben.
Code wie folgt anzeigen:
```
#include <QtCore>
class MyProcess : public QProcess { public: MyProcess() { connect(this, &QProcess::readyReadStandardOutput, [=](){ QByteArray output = this->readAllStandardOutput(); //QByteArray konvertiert in QString und entfernt den nachgestellten QString-Neuzeilentext (Ausgabe); text.chop(1); AusgabeBuffer.append(text); }); }
void stopProcess() { if (state() != QProcess::NotRunning) { terminate(); // SIGTERM-Signal senden waitForFinished(); // Warten, bis der Prozess beendet wird qDebug() <<outputBuffer; // Ausgabepuffer für Ausgabespeicher } }
protected:
QString-Ausgabepuffer;
};
int main(int argc, char *argv[])
{ QCoreApplication a(argc, argv);
MyProcess-Prozess;
process.start("your_program"); // Rufen Sie das Programm auf, das beendet werden muss
while(process.state() != QProcess::NotRunning){ a.processEvents(); //Lösen Sie die Hauptprozess-Ereignisschleife aus und verarbeiten Sie die eingehenden Ereignisse QByteArray Output = Process.readAllStandardOutput(); if(!output.isEmpty( )){ QString text(output); text.chop(1); qDebug() << text; //Echtzeitausgabe des Programmausgabeinhalts } }
Process.stopProcess(); // Programm beenden
return a.exec();
}
```
In diesem geänderten Code haben wir eine Membervariable „outputBuffer“ hinzugefügt, um den Ausgabepuffer des Programms zu speichern. In der Signal- und Slot-Funktion „readyReadStandardOutput()“ der MyProcess-Klasse wird die erhaltene Programmausgabe im Ausgabecache gespeichert.
Im Hauptprozess verwenden wir eine While-Schleife, um Ereignisse kontinuierlich zu verarbeiten und zu prüfen, ob eine Programmausgabe vorliegt.
Wenn das Programm eine Ausgabe hat, geben wir diese in Echtzeit aus. Andernfalls rufen wir nach Abschluss der Programmausführung erneut die Methode „stopProcess()“ auf, um den Ausgabepuffer des Programms auszugeben.
Auf diese Weise können wir die Ausgabe des Handlers in Echtzeit verfolgen. „Letztendlich wurde dieses Umsetzungsphänomen jedoch nicht realisiert.