Qt fournit la classe QProcess. Cette classe permet de contrôler l'exécution d'une application dans un nouveau process. Il est ainsi possible de contrôler :

• les variables d'environnement par la méthode setEnvironement() ;
• le répertoire d'exécution par setWorkingDirectory() ;
• de lancer l'application par la fonction start().

La fonction start() crée un processus enfant (qui sera fermé si le processus parent est fermé) avec, pour paramètres :

• le chemin de l'exécutable,
• la liste des paramètres d'entrée de l'exécutable,
• un mode d'ouverture pour interagir avec l'application par le biais des entrées/sorties standards.

Cette classe possède d'autres fonctions pour lancer une application :

• QProcess::execute : équivalent à start(). Bloquante jusqu'à la fin de l'exécution de l'application lancée ;
• QProcess::startDetached : permet de lancer une application dans un processus indépendant. Peut donner le PID du process créé.

Il est bon de remarquer que ces fonctions :

• ont des paramètres similaires à ceux de start() : le chemin de l'exécutable, et la liste des paramètres d'entrée de l'exécutable ;
• ne donnent pas de moyen pour interagir avec le process par le biais des entrées/sorties standard ;
• ces deux fonctions sont des fonctions statiques et peuvent être appelées sans création d'un QProcess. Dans ce cas, les variables d'environnement et le répertoire d'exécution seront les mêmes que ceux de l'application courante.

#include <QtGui>

class MyQPushButton : public QPushButton
{
    public :
    // créateur.
    // text : texte du bouton
    // exe  : commande à exécuter lors de l'appui.
    MyQPushButton(const QString & text,const QString & exe, QWidget * parent = 0)
    : QPushButton (text,parent),
    m_exe(exe)
    {
        resize(75, 30);
        setFont(QFont("Times", 18, QFont::Bold));
    };
    virtual void mouseReleaseEvent ( QMouseEvent * event )
    {
        // Lance la commande dans un processus indépendant
        QProcess::startDetached (m_exe);
    }

    private :
        QString m_exe;

};

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    QWidget w;
    QVBoxLayout vl(&w);
    // bouton : ouvre grâce au CMD la page vers DVP/Qt
    MyQPushButton bouton1("Ouvrir DVP / Qt","cmd /c start http://qt.developpez.com/",&w);

    // bouton : lance notepad
    MyQPushButton bouton2("Ouvrir notepad","notepad",&w);

     // bouton : lance invite de commande
    MyQPushButton bouton3("Ouvrir invite de commande","cmd" ,&w);
    vl.addWidget(&bouton1);
    vl.addWidget(&bouton2);
    vl.addWidget(&bouton3);
    w.show();
    return app.exec();
}

QProcess permet de lancer des applications externes (voir ici). Elle permet surtout d'interagir avec l'application à la manière d'un pipe au travers des entrées/sorties standards de l'application. Ainsi le troisième paramètre de la fonction start permet de spécifier quel type d'interaction on veut utiliser (par défaut, les deux types sont activés) :

• Mode read : récupération de la sortie standard (stdout) et d'erreur (stderr) ;
• Mode write : écriture sur l'entrée standard de l'application (stdin).

QProcess utilise les méthodes définies par QIODevice pour ces interactions. Pour la récupération des sorties, il faut faire attention au canal que l'on est en train de lire.

• pour la sortie standard il faut utiliser : QProcess::StandardOutput
• pour la sortie d'erreur il faut utiliser : QProcess::StandardError

De plus QProcess fournit deux signaux intéressants, qui indiquent si des données venant d'une des sorties sont arrivées.

• readyReadStandardOutput () : des données provenant de la sortie standard sont prêtes à être traitées
• readyReadStandardError () : des données provenant de la sortie d'erreur sont prêtes à être traitées

Ces interactions sont aussi possibles à l'aide de fichiers :

• setStandardErrorFile : fichier où l'on récupère la sortie d'erreur de l'application lancée ;
• setStandardOutput : fichier où l'on récupère la sortie standard de l'application lancée ;
• setStandardInputFile : fichier contenant les données à envoyer sur l'entrée standard de l'application lancée.

Sous Windows XP, un programme lisant l'entrée standard (stdin) en parallèle de son IHM peut se bloquer lorsqu'il est exécuté en process enfant. Ce défaut est normalement corrigé avec Windows Vista.