C++ Windows Winapi

Comment appeler efficacement `::CreateProcess` en C++ pour le lancement d’exécutables

Lors du développement d’applications en C++, vous pourriez occasionnellement avoir besoin de lancer des programmes exécutables externes depuis votre code. Cette tâche peut sembler décourageante au début, surtout lorsqu’il s’agit de s’assurer que votre application attend que le processus se termine et gère correctement les ressources système. Dans cet article, nous allons explorer comment utiliser efficacement la fonction ::CreateProcess de l’API Windows pour exécuter une application Windows, gérer son exécution et nettoyer les ressources.

Comprendre le problème

Vous pourriez avoir besoin de :

Lancer un exécutable (fichier .exe) depuis votre application C++.
Attendre que l’exécutable termine son exécution.
Fermer correctement tous les handles associés au processus pour éviter les fuites de ressources.

Utiliser `::CreateProcess` pour le lancement d’exécutables

La fonction CreateProcess est un moyen puissant de démarrer une autre application sous Windows. Elle vous permet de spécifier divers paramètres pour contrôler comment l’exécutable est exécuté. Ci-dessous, nous allons décomposer les étapes nécessaires pour l’implémenter dans votre programme C++.

Mise en œuvre étape par étape

Définir la structure STARTUPINFO : Cette structure contient des informations sur la façon dont le nouveau processus doit être démarré (comme l’apparence de la fenêtre).
```
STARTUPINFO info = { sizeof(info) };  
```
Définir la structure PROCESS_INFORMATION : Cette structure reçoit des informations sur le processus nouvellement créé et son thread principal.
```
PROCESS_INFORMATION processInfo;  
```
Appeler la fonction CreateProcess : Cette fonction prendra des paramètres qui spécifient le chemin de l’exécutable, les arguments de ligne de commande, les attributs de sécurité, et plus encore.
```
if (CreateProcess(path, cmd, NULL, NULL, TRUE, 0, NULL, NULL, &info, &processInfo)) {
    ...
}
```

Exemple de code complet

Voici un exemple complet qui regroupe tout :

#include <windows.h>

void LaunchExecutable(const char* path, const char* cmd) {
    STARTUPINFO info = { sizeof(info) };  
    PROCESS_INFORMATION processInfo;

    if (CreateProcess(path, cmd, NULL, NULL, TRUE, 0, NULL, NULL, &info, &processInfo)) {
        // Attendre que le processus se termine
        WaitForSingleObject(processInfo.hProcess, INFINITE);
        // Fermer les handles de processus et de thread
        CloseHandle(processInfo.hProcess);
        CloseHandle(processInfo.hThread);
    } else {
        // Gérer l'erreur (si nécessaire)
    }
}

Explication des composants clés

Paramètres de CreateProcess :
- path : Le chemin de l’exécutable que vous souhaitez exécuter.
- cmd : Arguments de ligne de commande passés à l’exécutable (peut être NULL si non utilisé).
- NULL, NULL : Attributs de sécurité par défaut pour le processus et son thread principal.
- TRUE : Handles hérités pour le processus et le thread (pour IPC ou d’autres usages).
- 0 : Drapeaux de création (0 indique un comportement par défaut).
Attente de la conclusion du processus :
- WaitForSingleObject(processInfo.hProcess, INFINITE) : Cette fonction bloque l’exécution jusqu’à ce que le processus spécifié se termine.
Nettoyage :
- N’oubliez jamais de fermer les handles à l’aide de CloseHandle pour éviter les fuites de mémoire et d’autres problèmes potentiels.

Conclusion

Lancer un exécutable Windows depuis une application C++ en utilisant ::CreateProcess est simple lorsque vous suivez la procédure décrite ci-dessus. S’assurer que vous attendez que l’exécutable se termine et que vous nettoyez les handles est essentiel pour la gestion des ressources. En suivant ces étapes, vous pouvez intégrer des applications externes dans votre flux de travail C++ de manière transparente.

Si vous avez d’autres questions ou si vous avez besoin de plus d’exemples sur l’utilisation de WinAPI, n’hésitez pas à nous contacter !

Comment appeler efficacement ::CreateProcess en C++ pour le lancement d’exécutables