IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)



Comment faire pour contrôler une application pendant un traitement long ?
auteur : Geronimo
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 tache ininterrompue lors du clic sur un bouton. Nous dessinons un quadrillage par rebonds successifs du pinceau sur les bords de la fenêtre. Déclarez 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énement 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 fonction é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énement OnClick, placez le code suivant : Stop = true . Ce qui donne la fonction suivante :
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 .
void __fastcall TForm1::FormCloseQuery(TObject *Sender, bool &CanClose)
{
    Stop = true;    
}

Comment réduire la taille d'un exécutable ?
auteur : Geronimo
La taille d'un exécutable dépend de nombreux facteurs. Voici cependant quelques solutions pour réduire la taille d'un programme : Si votre programme contient des images, convertissez-les en jpeg optimisées et compressées le plus possible (à vous de voir le rapport qualité/taille). Vous pouvez réduire la taille de votre programme en ne liant pas les librairies au-dedans. Pour cela, dans Projet/Options , cochez la case Utiliser la RTL dynamique de l'onglet Lieur et cochez la case Construire avec les paquets d'exécution de l'onglet Paquets . Mais attention, votre programme ne fonctionnera plus sur d'autres ordinateurs qui n'auront pas les paquets requis. Enfin, vous pouvez essayer d'utiliser les optimisations du compilateur : Projet/Modifier le fichier d'options . Dans le tag CFLAGS, remplacez le code -Od par -O1 . Par expérience, c'est surtout la première méthode qui se révêle la plus payante. La troisième n'ayant pas d'effet, la seconde obligeant à déployer les librairies séparemment, ce qui augmente plutôt la taille du fichier distribué.

Est-il intéressant pour les performances d'écrire des parties de programme en assembleur ?
auteur : Geronimo
Ecrire des parties de programme en assembleur peut permettre d'optimiser les performances de votre programme, mais ce n'est pas obligatoirement le cas. Tout d'abord, sachez que la compilation se termine par une phase d'optimisation ; c'est-à-dire que le compilateur va essayer de transformer au mieux les instructions pour les rendres plus rapides. Pour cela, il utilise du code assembleur adéquat. Donc quand vous écrivez des parties de programme en assembleur, il faut être vraiment sur que votre code sera plus performant que celui créé par le compilateur. Il faut alors que vous maitrisiez (très) bien l'assembleur. Ainsi, surtout si vous êtes débutant, il n'est pas nécessaire d'essayer de remplacer du code C++ par de l'assembleur, pensant optimiser votre programme.