Como fechar um programa no Windows:
No código Qt, às vezes o qprocess precisa chamar um programa de terceiros e precisa ser encerrado após a conclusão da chamada. Não é adequado desembolsar manualmente. Neste momento, você pode chamar o programa taskkill na janela para fechar o programa.
Processo QProcess;
process.execute("taskkill /im xx.exe /f");
Como fechar um programa no Linux
Você pode usar o comando kill para encerrar um processo no Ubuntu. Para usar o comando kill no código Qt, isso pode ser feito herdando a classe QProcess.
código mostrado abaixo:
```
#include <QtCore>
class MyProcess : public QProcess { public: void stopProcess() { if (state() != QProcess::NotRunning) { termina(); // Envia sinal SIGTERM waitForFinished(); // Aguarda o término do processo } } } ;
int main(int argc, char *argv[])
{ QCoreApplication a(argc, argv); MyProcess process; process.start("seu_programa"); //Chama o programa que precisa ser finalizado
process.stopProcess(); // Finaliza o programa
retornar a.exec();
}
```
A classe personalizada MyProcess é usada aqui para herdar QProcess, e o método stopProcess() é adicionado para implementar a função de encerrar o processo.
O método stopProcess() enviará primeiro o sinal SIGTERM para encerrar o processo e, em seguida, aguardará que o processo termine completamente. Se waitForFinished() não for chamado, o processo poderá ser encerrado sem ser completamente encerrado.
Continue a melhorar este código, encapsulando o conteúdo de saída do programa de console executado na classe MyProcess e exibindo-o em qdebug em tempo real.
Procurando uma solução melhor, ok, posso continuar melhorando esse código para encapsular o conteúdo de saída do programa de console executado e exibi-lo no QDebug em tempo real.
O código modificado é o seguinte:
```
#include <QtCore>
class MyProcess : public QProcess { public: MyProcess() { connect(this, &QProcess::readyReadStandardOutput, [=](){ QByteArray output = this->readAllStandardOutput(); //QByteArray converte em QString e remove a nova linha final do texto QString (saída); text.chop(1); qDebug() << texto; }); }
void stopProcess() { if (state() != QProcess::NotRunning) { termina(); // Envia sinal SIGTERM waitForFinished(); // Aguarda o término do processo } } };
int main(int argc, char *argv[])
{ QCoreApplication a(argc, argv); MyProcess process; process.start("seu_programa"); //Chama o programa que precisa ser finalizado
process.waitForFinished(); //Aguarda o término da execução do programa
retornar a.exec();
}
```
No construtor da classe MyProcess, adicionei uma expressão lambda conectada ao sinal `readyReadStandardOutput()` do QProcess para obter o conteúdo gerado pelo programa chamador em tempo real e produzi-lo em tempo real por meio do QDebug.
Então, no programa, chamamos o método waitForFinished() do processo e esperamos que o programa conclua a execução. Durante a execução do programa, a classe MyProcess enviará o conteúdo de saída obtido do programa de chamada para o console.
Nota: Usar o método waitForFinished() bloqueará a execução do programa. Se uma grande quantidade de conteúdo de saída for gerada, o programa poderá não conseguir responder devido ao bloqueio. Se precisar evitar o bloqueio, você pode usar os sinais e slots do QProcess.
Neste exemplo, qDebug() << text; é executado após stopProcess() process.waitForFinished(); aguardar o término da execução do programa antes de imprimi-lo. Existe uma maneira de gerar informações de saída em tempo real do programa executado em tempo real?
Este problema ocorre porque `qDebug() << text` usa uma operação assíncrona na função de slot de sinal na classe MyProcess. Ou seja, quando a saída do programa é obtida, uma notificação de sinal é enviada ao thread principal para saída. Pode ainda estará no thread principal. Aguarde a execução do programa, portanto, é necessário aguardar até que o programa seja executado antes de sair.
Para obter a saída em tempo real das informações de saída do programa em execução, precisamos mover a saída de `qDebug() << text` para o processo principal para execução. A implementação específica pode ser estabelecendo um loop no processo principal para ler o cache de saída armazenado na classe MyProcess em tempo real e enviá-lo para o console.
código mostrado abaixo:
```
#include <QtCore>
class MyProcess : public QProcess { public: MyProcess() { connect(this, &QProcess::readyReadStandardOutput, [=](){ QByteArray output = this->readAllStandardOutput(); //QByteArray converte em QString e remove a nova linha final do texto QString (saída); text.chop(1); saídaBuffer.append(texto); }); }
void stopProcess() { if (state() != QProcess::NotRunning) { termina(); // Envia sinal SIGTERM waitForFinished(); // Aguarda o término do processo qDebug() << outputBuffer; // Buffer de saída para armazenamento de saída } }
protegido:
QString outputBuffer;
};
int main(int argc, char *argv[])
{ QCoreApplication a(argc, argv);
MyProcess process;
process.start("seu_programa"); //Chama o programa que precisa ser finalizado
while(process.state() != QProcess::NotRunning){ a.processEvents(); //Aciona o loop de eventos do processo principal e processa os eventos recebidos QByteArray output = process.readAllStandardOutput(); if(!output.isEmpty( )){ QString text(output); text.chop(1); qDebug() << text; //Conteúdo de saída do programa de saída em tempo real } }
process.stopProcess(); // Finaliza o programa
retornar a.exec();
}
```
Neste código modificado, adicionamos uma variável de membro `outputBuffer` para armazenar o buffer de saída do programa. No sinal `readyReadStandardOutput()` e na função de slot da classe MyProcess, a saída do programa obtida é armazenada no cache de saída.
No processo principal, usamos um loop while para processar eventos continuamente e verificar se há saída do programa.
Se o programa tiver saída, iremos produzi-la em tempo real, caso contrário, após a conclusão da execução do programa, chamaremos o método `stopProcess()` novamente para gerar o cache de saída do programa.
Dessa forma, podemos acompanhar a saída do manipulador em tempo real. “Mas no final, este fenómeno de implementação não se concretizou.