Gestion de l'exécution en C++
11.27.2005
(Le texte de cette page provient du site: http://c.developpez.com/faq/bcb/?page=gestionexecution)
Comment exécuter des commandes ?
Pour cela, utilisez la fonction system, déclarée dans stdlib.h, qui prend pour argument la commande à exécuter :
#include
//...
system("dir *.*");
Comment exécuter une commande et en récupérer le résultat ?
Pour récupérer le résultat de l'exécution d'une commande, il suffit d'utiliser la fonction system, définie dans stdlib.h, pour lancer une commande, et de spécifier une redirection de sortie (celles-ci fonctionnent aussi bien sous DOS/Windows que sous Linux) :
#include
// Version DOS/Windows :
system("dir *.* > results.txt");
// Version Linux : /* L'option -l permet d'avoir les détails des fichiers */
system("ls -l > results");
Le résultat de la commande se situe maintenant dans le fichier results.txt ou results.
Comment exécuter un programme externe ?
Utilisez la fonction ShellExecute.
Pour lancer Notepad, par exemple :
ShellExecute(
NULL, // Handle de la fenêtre parent
"open", // Action à effectuer
"notepad.exe", // Fichier
"", // Paramètres
"", // Répertoire par défaut
SW_SHOWDEFAULT // Manière d'afficher );
Attention, les chaînes passées en arguments de cette fonction sont des chaînes C standard. Pour passer des AnsiString en arguments, utilisez la méthode c_str() :
// Affiche une boîte de dialogue "Ouvrir un fichier" et ouvre le fichier avec notepad.
if (OpenDialog1->Execute())
{
ShellExecute(
NULL, // Handle de la fenêtre parent
"open", // Action à effectuer
"notepad.exe", // Fichier
OpenDialog1->FileName.c_str(), // Paramètres
ExtractFilePath(OpenDialog1->FileName).c_str(), // Répertoire par défaut
SW_SHOW // Manière d'afficher ); }
Comment récupérer les arguments de la ligne de commande passés à mon exécutable ?
Cela peut être effectué grâce aux fonctions ParamCount() et ParamStr(), la seconde prenant en argument le numéro de l'argument.
Dans l'exemple suivant, nous chargeons dans un TMemo le fichier placé en argument de la ligne de commande. Placez le code suivant dans le constructeur de votre fiche :
if ( ParamCount() > 0 )
Memo1->Lines->LoadFromFile(ParamStr(1));
Comment générer une alerte à destination de l'utilisateur ?
Il est souvent utile d'avertir l'utilisateur par un message rapide, pour lui faire part d'une information ou pour lui signaler une erreur. Il existe différentes méthodes. Les plus simples et les plus utiles sont ShowMessage et MessageDlg.
ShowMessage permet d'afficher un message tout simple dans une fenêtre. Elle prend pour argument une AnsiString qui est le contenu du message.
ShowMessage("Tâche effectuée");
L'autre méthode, plus perfectionnée, est MessageDlg. Cette fonction permet de personnaliser un peu la boîte de dialogue :
MessageDlg("La tâche a été effectuée correctement", mtInformation, TMsgDlgButtons() << mbOK, 0);
Cette fonction permet d'afficher un message (AnsiString passée en premier argument). Le second argument indique le type de boîte de dialogue. mtInformation affiche une icône "information" dans la boîte de dialogue. Enfin, l'avant-dernier argument permet de choisir quels boutons seront disponibles dans la boîte de dialogue. Le dernier argument permet de lier la boîte de dialogue à une rubrique d'aide. Un des grands avantages de cette fonction est qu'elle permet de savoir quel bouton a été enfoncé s'il y en avait plusieurs :
if (MessageDlg("Le document n'a pas été sauvegardé, voulez-vous le sauvegarder avant de quitter ?", mtConfirmation, TMsgDlgButtons() << mbYes << mbNo, 0) == mrYes)
Sauver();
Dans ce code, la méthode Sauver est appellée si le bouton Oui est cliqué. Pour plus de détails sur le fonctionnement de MessageDlg, consultez l'aide de C++Builder.
Comment faire pour qu'un traitement long ne fige pas l'application ?
Lors d'un traitement long, l'application ne traite plus les messages Windows de la queue de messages.
Le résultat est en général une aplication qui ne répond plus aux évenements utilisateurs, ou qui ne se redessine plus.
Dans ce cas, il faut faire un appel à la méthode ProcessMessages de la classe Application dans la boucle. L'exemple présenté ci-dessous déclenche une tâche ininterrompue lors du clic sur un bouton. Nous dessinons un quadrillage par rebonds successifs du pinceau sur les bords de la fenêtre. Déclarons tout d'abord une variable Stop en global :
//...
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm" TForm1 *Form1;
bool Stop; /* Placez la variable ici */ //---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
{
//...
}
Maintenant, nous allons écrire le gestionnaire d'événements OnClick du bouton de dessin.
void __fastcall TForm1::Button1Click(TObject *Sender)
{
static int x_inc = 1; // Incrémentation d'abscisse
static int y_inc = 1; // Incrémentation d'ordonnée
static int X = 10; // Position initiale (abscisse)
static int Y = 10; // Position initiale (ordonnée)
Stop = false; // La boucle est activée.
/* Le seul moyen d'arrêter la boucle est de positionner la variable Stop à true */
while(!Stop) { Canvas->MoveTo(X, Y); // Placement du pinceau en (X, Y)
X += x_inc; // Incrémentation des positions
Y += y_inc; // Change la couleur de la ligne aléatoirement
Canvas->Pen->Color = RGB(rand()%255, rand()%255, rand()%255);
Canvas->LineTo(X, Y); // Ligne jusqu'à la nouvelle position
/* Si la position du pinceau sort de la zone cliente de la fenêtre, on inverse les incrémentations, ce qui donne l'effet de "rebond" */
if (X > ClientWidth || X < 0) x_inc = -x_inc;
if (Y > ClientHeight || Y < 0) y_inc = -y_inc;
/* L'appel à cette méthode évite le blocage de l'application : les messages et clics sur autres boutons sont traités */
Application->ProcessMessages();
}
}
Maintenant, il nous faut pouvoir arrêter cette boucle dessin. Pour cela, nous avons vu qu'il suffit de placer la variable Stop à true. Placez un autre bouton sur la fiche. Dans son gestionnaire d'événements OnClick, placez le code suivant :
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Stop = true;
}
Si un clic sur le bouton a lieu, il sera traité par l'appel à Application->ProcessMessages(). Enfin, il faut pouvoir quitter le programme. Pour cela, utilisez l'événement OnCloseQuery de la fiche et placez-y également le code Stop = true.
Comment faire une courte pause de quelques millisecondes ou secondes ?
Utilisez la fonction Sleep en lui passant en argument le nombre de millisecondes.
// Pause d'une seconde :
Sleep(1000);
Notez qu'en raison du fonctionnement interne de Windows, Sleep ne garantit qu'un minimum d'attente. En effet, Windows n'est pas un système temps-réel.
posted by mAt @ 11:39 PM
