Sur cette page, je vais essayer de regrouper les principales questions qui m'ont été posées par mails, qui m'ont pour certaines demandé pas mal d'efforts pour les réponses, ou même, dans certains cas, des questions que je me suis moi-même posé, et dont  j'ai eu des difficultés à venir à bout...
    Naturellement, il est impossible que toute question ait sa réponse ici, mais, avant de m'écrire, ça serait sympa de votre part de lire cette page, quitte à me demander plus de précisions ultérieurement...
    Je tiens aussi à préciser que certaines questions/réponses que je propose ici sont présentes dans la doc (et, plus précisément, dans la FAQ) de TIGCC, mais qu'on me les as tout de même posé... dans de tels cas, je me suis bien souvent contenté d'un renvoie vers TIGCC, ou, à la limite, d'un couper-coller ! S'il vous plait, ne m'écrivez pas pour me poser des questions auxquelles Zeljko Juric a déjà répondu ! (Sauf si vous ne comprenez pas la réponse.) Je crois que vous gagnerez plus de temps en étudiant un peu la FAQ de TIGCC qu'en m'écrivant pour des questions dont la réponse est déjà donnée, et en attendant la réponse !
    Enfin, par soucis d'intimité pour chacun d'entre vous, je ne nommerai pas les gens qui m'ont posé ces questions : les seules personnes qui pourront voir leur nom ici cité seront celles qui m'auront aidé à répondre à des questions, que ce soit par mail, ou sur le forum de TI-FR, et, à chaque fois, leur nom ne sera placé ici que si elles m'y ont autorisé.
    Je vais aussi vous demander de m'excuser si je fais ici quelques remarques un peu "acides" : certaines question à forte occurrence ont parfois tendance à me rendre hors de moi !


Liste des Questions : (Elles sont en vrac, dans l'ordre où je les reçois et où je réponds !)

  1. Ou puis-je trouver de la doc pour programmer en C ?
  2. Comment peut-on écrire des caractères spéciaux à l'écran de la TI ? (De façon équivalente à ce qu'on peut obtenir avec l'instructions char, en TI-BASIC).
  3. Comment faire pour sauvegarder la totalité de l'écran graphique à un moment du programme, afin de pouvoir le rappeler plus tard ? 
  4. Comment faire pour convertir une suite de chiffres (autrement dit, un nombre) en une chaîne de caractères, qui soit utilisable en temps que tel, par exemple pour l'afficher à l'écran ?
  5. Quelle est la différence entre les pointeurs de type HSym et ceux de type SYM_ENTRY, pour les manipulations de la VAT ?
  6. Comment peut-on Zipper ou Dézipper des fichiers de la TI en utilisant la librairie ZipLib de Marc Teyssier ?
  7. J'ai plusieurs fois essayé d'utiliser la fonction EM_survey, pour savoir de quelle quantité de mémoire d'archive libre je disposais, mais je ne réussis pas à faire tourner cette fonction de façon correcte...
  8. Comment puis-je entrer des valeurs pendant l'exécution d'un programme, de la même façon que je pourrai le faire sur PC en utilisant la fonction scanf ?
  9. Comment puis-je écrire un programme de type TSR et le faire fonctionner correctement ?
  10. Pourquoi te fatigues-tu à créer des programmes et même des chapitres dans deux version différentes ? Pourquoi ne pas développer ton tutorial uniquement pour TI-89 ?
  11. Apporter des modifications à l'écran mais qui soient encore visibles après la fin du programme : comment faire ?
  12. Comment puis-je créer une variable de type EXPR visible dans le VAR-LINK à partir de mon programme en C ?
  13. Comment faire pour optimiser mon programme au niveau de la mémoire ?
  14. Mon programme me fait "perdre" de la mémoire RAM... Comment faire ?

    Où puis-je trouver plus de documentation sur la programmation en C, que ce soit sur PC, ou sur TI ?

Si vous avez vous-même un site traitant de programmation en C, vous pouvez m'envoyer l'adresse, pour que je la rajoute ici...


    Comment peut-on écrire des caractères spéciaux à l'écran de la TI ? (De façon équivalente à ce que l'on peut obtenir avec l'instruction char, en TI-BASIC).

Il doit être possible d'utiliser l'instruction suivante :
        DrawChar(x, y, nombre, mode);
nombre correspond au code TI-BASIC pour les caractères char. Ainsi, remplacer nombre par 174 permettra d'obtenir ®. Cette fonction écrit à la position définie par le point d'abscisse x et d'ordonnée y. mode correspond à la façon dont sera affiché le caractère.
    Par exemple, il est possible de faire :
        ClrScr();
        DrawChar(50, 10, 174, A_NORMAL);
        ngetchx();
    Ce morceau de code va écrire le caractère ® à la position (50; 10)

Remarque : Si vous consultez la doc de TIGCC concernant cette fonction, vous pourrez remarquer que nombre est défini comme une variable de type char. Cela signifie qu'il s'agira d'une valeur codée sur 8 bits (et oui, une valeur chiffrée, comprise entre 0 et 254 !), comme tous les caractères de la TI.


    Comment faire pour sauvegarder la totalité de l'écran graphique à un moment du programme, afin de pouvoir le rappeler plus tard ? 

    Ce petit extrait de code source va vous montrer comment résoudre ce problème :

#include <tigcclib.h>

short _ti92plus;

void _main(void)
{
 
LCD_BUFFER buffer;   // Déclare la variable de sauvegarde d'écran buffer
  // Début du programme, les instructions à exécuter...
 
LCD_SAVE(buffer);
     // Cette fonction sauvegarde l'écran dans buffer.
  // la suite du programme
 LCD_RESTORE(buffer);
 
// Cette fonction rappelle l'écran sauvegardé précédemment
// Suite et fin du programme
}

    Cette manipulation est d'ailleurs celle qu'il fallait toujours utiliser, pour chaque programme, avec les anciennes versions de TIGCC, avant que SAVE_SCREEN ne soit implémentée...


    Comment faire pour convertir une suite de chiffres (autrement dit, un nombre) en une chaîne de caractères, qui soit utilisable en temps que tel, par exemple pour l'afficher à l'écran ?

    Pour convertir un nombre en chaîne de caractères, il est possible d'utiliser la portion de codes suivante :
   char string1[50];
   char string2[50];
   short var1 = 0;
   ti_float var2 = 0;
   // Le code du programme, qui affecte, entre autre, des valeurs aux variables var1 et var2...
   sprintf(string1, "%d", var1);
   sprintf(string2, "%f", var2);

    L'instruction sprintf utilisée ici permet de remplir les chaînes de caractère string1 et 2 avec les valeurs des shorts et floats var1 et 2...
    Pour plus de renseignements concernant cette fonction, vous pouvez consulter le Chapitre XXIV du tutorial.


    Quelle est la différence entre les pointeurs de type HSym et ceux de type SYM_ENTRY, pour les manipulations de la VAT ?

    Le pointeur de type HSym est défini de cette façon :
typedef struct
{
 
HANDLE folder;
 
unsigned short offset;
}
HSym;

    Et le pointeur de type SYM_ENTRY est défini de cette façon :
typedef struct
{
 
char name[8];
  unsigned short compat;
 
union
  {
    unsigned short flags_n;
    struct
    {
      unsigned short busy : 1, local : 1, flag1_5 : 1, flag1_4 : 1, collapsed : 1, twin : 1, archived : 1, in_view : 1;
      unsigned short folder : 1, overwritten : 1, checked : 1, hidden : 1, locked : 1, statvar : 1, graph_ref_1 : 1, graph_ref_0 : 1;
    }
bits;
  }
flags;
  unsigned short handle;
}
SYM_ENTRY;

    On peut ainsi voir que le pointeur de type SYM_ENTRY permet d'accéder à beaucoup plus de choses concernant la variable pointée que celui de type HSym. En effet, celui-ci ne permet d'accéder qu'à l'offset de la variable, alors que le pointeur de type SYM_ENTRY permet d'accéder aux flags qui déterminent l'état de la variable.
    C'est pour cela que c'est en utilisant des pointeurs de type SYM_ENTRY qu'on peut cacher une variable, la verrouiller, ou alors détecter si elle est archivée, si elle est sélectionnée...

    Ainsi, les deux types de pointeurs sont utilisés par des instructions différentes, pour des buts différents.


    Comment peut-on Zipper ou Dézipper des fichiers de la TI en utilisant la librairie ZipLib de Marc Teyssier ?
Je suis désolé de poser cette question, mais, malgré le long topic que Zeljko Juric a écrit à ce sujet dans la FAQ de TIGCC, je n'arrive pas à compresser ou décompresser des variables en utilisant ZipLib... A chaque fois, je n'ai pas de problème lors de la compilation, mais j'obtient une "Adress Error" au moment de faire l'appel à ZipLib... Comment puis-je faire pour utiliser ces fonctions ?

    Dans la FAQ de TIGCC, Zeljko Juric donne cette macro :
#define compress(src, dest, len) \
  ({ void *__src = (src), *__dest = (dest); \
     unsigned long __len = (len); \
     asm ("move.l %0,%%a0" :: "g"(__src)); \
     asm ("move.l %0,%%a1" :: "g"(__dest)); \
     asm ("move.w %0,%%d0" :: "g"(__len)); \
     asm ("jsr ziplib__0004"); })

Le problème est, à mon avis, que la fonction ziplib__004 ne sert pas à compresser des variables du TIOS (qui apparaissent dans le VAR-LINK), mais des données internes au programme (comme le montre le terme de "data" employé). En effet, voici l'extrait de la doc de ZipLib qui correspond à cette fonction :
   ;----------------------------------------------------------------------------
    ; compress()
    ;
    ; Function: compress data
    ;
    ; Input: A0 = Pointer to uncompressed data
    ;             A1 = Pointer to where the compressed data should be stored
    ;             D0.W = Length of datas which will be compressed
    ;----------------------------------------------------------------------------
        ziplib::compress equ ziplib@0004

A mon avis, c'est plutôt la fonction ziplib__006 qu'il conviendrait d'utiliser pour compresser ou décompresser des fichiers ("file") apparaissant dans le VAR-LINK. En effet, voici l'extrait de la doc de ZipLib qui se rapport à cette fonction :
   ;----------------------------------------------------------------------------
    ; zipfile()
    ;
    ; Function: Compress or Extract a file
    ;
    ; Input: A0 = Pointer to file in the VAT
    ;             D0.B = 0 disable commentary
    ;                          1 semi-commentary (error displayed)
    ;                          else enable commentary (Windows, Confirmations,...)
    ;
    ; Output: D0.B = 0 no error
    ;                             1 cant manipulate because file is archived
    ;                             2 compressed file bigger than original
    ;                             3 not enough memory
    ;                             4 Program running
    ; NO OTHER REGISTERS DESTROYED
    ;----------------------------------------------------------------------------
        ziplib::zipfile equ ziplib@0006

Ici, on peut voir que cette fonction est conçue pour compresser ET décompresser des "files", c'est-à-dire des fichiers.

Maintenant, il faut parvenir à utiliser cette fonction, afin d'arriver à compresser ou décompresser une variable. Voici la routine que j'ai réussi à écrire pour faire cela. Je ne garantit pas qu'elle soit parfaite : à toute fin utiles, je précise que je connais quasiment rien à l'ASM : même si j'arrive à comprendre en partie la logique de certains sources ASM, je ne sais pas encore écrire de "gros programmes" en ce langage (Et, pour compliquer le tout, l'ASM qu'il faut utiliser sous TIGCC est du GNU ASM, et non le l'ASM A68k...). Donc, c'est après beaucoup d'essais infructueux que j'ai fini par obtenir cette macro, qui fonctionne sans plantage :
#define ZipFile(src, msg) \
  ({ void *__src = (src); \
     short int __msg = (msg); \
     asm ("move.l %0,%%a0" :: "g"(__src)); \
     asm ("move.b %0,%%d0" :: "g"(__msg)); \
     asm ("jsr ziplib__0006"); })
Pour pouvoir utiliser cette macro dans votre programme, il vous suffit de l'inclure dans votre source. Ensuite, pour compresser ou décompresser un fichier (il n'y a pas de test effectué : cette fonction inverse l'état de la variable !), il faudra lancer cette macro de cette façon :
        ZipFile(SymFindPtr($(nom_de_la_var)), 0), commentaire);
En fait, le premier argument de cet fonction doit être un pointeur de type SYM_ENTRY vers la variable, et le second est une valeur chiffrée qui vous permet d'activer ou non les commentaires.
    Si commentaire=0, il n'y aura pas de commentaires, si commentaire=1, il n'y aura que quelques commentaires (messages d'erreur), et si commentaire=une autre valeur, tous les commentaires seront autorisés.

Voilà, j'espère que, maintenant, je ne recevrai plus cette question...


    J'ai plusieurs fois essayé d'utiliser la fonction EM_survey, pour savoir de quelle quantité de mémoire d'archive libre je disposais, mais je ne réussis pas à faire tourner cette fonction de façon correcte... Pourras-tu m'aider ?

    Voilà une question qui m'est bien souvent parvenue, et qui a de nombreuses fois été postée sur le forum de TI-Fr. Je vais ici y répondre, en espérant ne plus la recevoir elle non plus...

    Dans la doc de TIGCC, la fonction EM_survey est définie comme ceci :
        EM_survey (unsigned long *inUse, unsigned long *freeAfterGC, unsigned long *free, unsigned long *unusedSectors, unsigned long *badSectors, unsigned long *allExceptBaseCode);
    Cette fonction prend en arguments 6 pointeurs vers des variables de type unsigned long.
    Voici leurs significations, d'après ce que j'ai compris, et les tests que j'ai effectué :

    Si l'un de ces arguments ne vous intéresse pas, il vous sera possible de passer NULL à la place.

Pour déterminer la quantité de mémoire libre que vous avez dans votre TI, il vous faudra faire ceci :
        unsigned long freeAfterGC;
        unsigned long free;
        EM_survey(NULL, &freeAfterGC, &free, NULL, NULL, NULL);
A présent, les variables free et freeAfterGC doivent être additionnées pour vous donner ce que vous cherchez. Pour l'afficher, il faudra faire :
        printf("Mémore d'Archive libre : %lu", freeAfterGC+free);

    Les erreurs que j'ai souvent vu dans les extrait de code que l'on m'a envoyé sont :

    Je tiens aussi à vous prévenir d'un chose : certaines valeurs que vous pourrez obtenir à partir de cette fonction seront différentes de celles que vous pourrez lire dans le menu MEM de votre TI. Cela est du au fait que, dans ce menu, la lecture n'est pas faite en se basant sur les même calculs... En fait, les valeurs que vous obtiendrez avec la fonction EM_survey correspondent plutôt à celles que vous pourrez obtenir en utilisant la commande TI-BASIC getConfg().


    J'ai cherché pendant pas mal de temps dans la doc de TIGCC, mais je n'ai pas réussi à trouver la fonction scanf (petite précision, cette fonction sert, en ANSI-C, à acquérir des données : c'est l'équivalent de printf, mais en Input au lieu de Output). Comment puis-je faire pour passer des valeurs au programme pendant son exécution ? Comment est-ce possible de remplacer cette fonction dans TIGCC ?

    Effectivement, il est normal que tu n'ai rien trouvé correspondant à scanf dans la doc de TIGCC. En effet, cette fonction n'est pas présente dans ce logiciel ! Mais, pour pallier à ce problème, Zeljko Juric donne une fonction remplissant en gros le même rôle, dans la FAQ de TIGCC. Voici cette fonction :

void InputStr(char *buffer, short maxlen)
{
 
SCR_STATE ss;
 
short key, captured, i=0;
 
void CaptureHandler (EVENT *ev)
    {
     
if (ev->Type == CM_STRING)
       
captured = *(ev->extra.pasteText);
    }
 
buffer[0] = 0;
 
SaveScrState (&ss);
 
do
   
{
     
MoveTo (ss.CurX, ss.CurY);
     
printf ("%s_  ", buffer);
       
// Note that two spaces are required if F_4x6 font is used
     
key = ngetchx();
     
if (key == KEY_CHAR && i < maxlen)
        {
         
EVENT ev;
         
ev.Type = CM_KEYPRESS;
         
ev.extra.Key.Code = key;
         
EV_captureEvents (CaptureHandler);
         
EV_defaultHandler (&ev);
         
EV_captureEvents (NULL);
         
buffer[i++] = captured;
        }
     
if (key >= ' ' && key <= '~' && i < maxlen) buffer[i++] = key;
     
if (key == KEY_BACKSPACE && i) i--;
     
buffer[i] = 0;
    }
while (key != KEY_ENTER);
}

    Cette fonction doit être utilisée de la façon suivante :
        InputStr(str_a_remplir, nbr_max_de_caracteres);
    Le premier argument correspond à une chaîne de caractères, et le second correspond au nombre maximal de caractères que la fonction acceptera de lire. Attention : la chaîne de caractères str_a_remplir doit être assez grande pour pouvoir contenir tous les caractères qui seront captés par la fonction !

Ensuite, la variable str_a_remplir contiendra ce que vous aurez entré pendant l'exécution de la fonction. Ces données constituerons une chaîne de caractères. Donc, si vous voulez utiliser une données chiffrée, il vous faudra convertir cette chaîne de caractères ! Voila comment faire pour certains types de variables : (les autres types de variables doivent être convertis de façon équivalente).


    Je cherche à écrire des programmes de type TSR à partir de TIGCC. Pour cela, j'utilise l'exemple donné par Zeljko Juric dans l'aide du fichier <events.h>. Mon problème est que, suite au lancement des programmes que je crée de cette façon, il ne m'est plus possible d'utiliser le port link de ma TI, et j'obtient un plantage en utilisant les menus CATALOG et ABOUT !!! Comment puis-je faire pour résoudre ce problème, en ayant tout de même la possibilité de créer mes propres programmes TSR ???

    Voilà une question que j'ai souvent reçu, et, sans nul doute, une de celles qui m'a le plus intéressé, puisque j'ai moi-même eu ce genre de difficultés quand j'ai commencé à vouloir développer mes propres programmes de type TSR pour mon usage personnel...

    Effectivement, la technique donnée par Zeljko Juric pour créer des programmes de type TSR (Terminate and Stay Resident, c'est-à-dire restant actif en permanence, tant qu'il n'a pas été désinstallé, ou tant que l'on a pas fait effectuer un Reset à la TI) ne fonctionne pas à merveille !

    En fait, je suis parfaitement incapable de développer le type de routine permettant de faire des programmes de type TSR, et, pour tout dire, je n'ai pas vraiment cherché à le faire ! Mais bon, puisqu'on me demande... J'ai trouvé un site sur lequel il est possible de télécharger un programme de ce style en Open-source, et en C. Voici l'adresse : http://www.geocities.com/gdietsche/
    L'avantage de ce programme est qu'il vous permet d'écrire des programmes de type TSR qui soient compatibles avec la norme fixée par Kevin Kofler, notamment au sujet de la position en RAM, ou de la désinstallation...

    Malheureusement, le programmeur qui a développé cet exemple l'a écrit en anglais, mais, à mon avis, vous n'aurez pas besoin de trop de connaissances dans cette langue pour comprendre, et parvenir à développer vos programmes à partir de là.
    J'ai moi-même testé cette solution de création de programmes de type TSR, et je peux confirmer qu'elle fonctionne : j'utilise en permanence sur ma TI un programme que j'ai développé de cette façon !


    Pourquoi te fatigues-tu à créer des programmes, et même des chapitres entier dans deux versions différentes pour deux calculatrices ? Ne te serait-il pas plus simple de ne développer ton tutorial que pour TI-89 ? Après tout, je crois bien que cette calculatrice est nettement plus représentée que que la TI-92+ !

    Voila une question qui me dérange très profondément !
    Il est absolument HORS DE QUESTION que je cesse de développer ce tutorial pour les TI-92plus ! En effet, c'est la calculatrice que je possède moi même !!! En fait, tous les programmes et/ou chapitres qui sont ici présentés pour TI-89 ne sont rien de plus que les versions que j'ai écrit pour TI-92+ que j'ai par la suite porté pour TI-89 !
    Donc, si jamais je venais à manquer considérablement de temps, ce sont les version pour TI-89 qui disparaîtraient, et nullement celles pour TI-92plus, et ce même s'il y a beaucoup plus de gens qui utilisent des TI-89 que des TI-92plus !

    Même si cela dérange certains d'entre vous de télécharger des version pour TI-92plus alors que vous avez des TI-89, je vous demanderai de ne pas oublier que je passe beaucoup de temps à écrire ce tutorial, que je le fait bénévolement, que je passes moi-même pas mal de temps de mon forfait à l'envoyer à mon hébergeur (l'inconvénient des connexions lentes !), et que si je n'avais pas ma TI-92+, je ne l'aurai pas écrit !!!
    De plus, ce tutorial est écrit en bonne partie parce qu'il me permet d'apprendre de nouvelles choses concernant la programmation sur ma 92+, et parce que j'aime beaucoup, entre autre, recevoir des mails me prouvant que mon tutorial est apprécié. Par contre, ce genre de question m'est assez insupportable ! Je vous serait donc reconnaissant de ne plus me la poser. Merci !


    Pendant l'exécution de mon programme, je modifie les indicateur d'angle dans la ST, et je peux voir sur l'écran qu'ils ont bien été modifiés. Par contre, une fois que je quitte le programme, ceux-ci reviennent à ce qu'ils étaient avant que je n'exécute le programme... Comment faire pour éviter cela, c'est-à-dire que ces indicateurs restent à ce que j'ai fixé ?

    C'est tout simple : tu utilises #define SAVE_SCREEN dans ton source, je penses ? (=> OUI !). Eh bien, cette instruction fait que l'écran est sauvegardé au lancement du programme, et qu'il est restauré à la sortie du programme... Donc, les indicateurs qui apparaîtront dans la ST après l'exécution du programme seront les mêmes que ceux qui étaient affichés au lancement !

    Pour éviter ceci, il faut que tu sauvegarde manuellement l'écran au début du programme, que tu le rappelle avant de quitter, et, seulement après l'avoir rappelé, tu modifie les indicateurs... Voici, en gros, comment il faut faire :
LCD_BUFFER sauv_ecran;    // Déclare l'espace mémoire nécessaire à la sauvegarde de l'écran.
LCD_save(sauv_ecran);    // Sauvegarde l'écran dans cet espace mémoire.
// ... ton programme, qui modifie l'écran, qui l'efface...
LCD_restore(sauv_ecran);    // Rappelle l'écran précédemment sauvegardé.
// Et là, tu peux modifier ce que tu veux, cela restera visible après la sortie du programme.
// Naturellement, il ne faut pas utiliser #define SAVE_SCREEN au lancement du programme !

    Avant la version 0.8 de TIGCC, la macro SAVE_SCREEN n'existait pas. Il fallait alors toujours utiliser cette technique pour sauvegarder l'écran au début d'un programme, et le restaurer après !

    ATTENTION : Cette opération n'est possible qu'en mode Nostub. En effet, les Kernels sauvegardent eux-même l'écran au lancement des programmes, et le restaurent avant de quitter ! Il n'est donc pas possible de modifier l'écran de la sorte avec un programme de type Kernel (Enfin, du moins, ce n'est pas encore possible...)...


    Je voudrais créer une variable de type EXPR (qui apparaisse en tant que telle dans le menu VAR-LINK) à partir de mon programme en C... Comment puis-je faire ?

    C'est une bonne question que tu poses ici ! En effet, il est très complexe de créer des variables d'un autre type que STR ou TEXT !
    La réponse que je vais ici donner provient du forum C de TI-Fr. Elle ne permet que de créer des variables de type EXPR simples, c'est-à-dire ne contenant rien de plus qu'une valeur chiffrée : pas de formule symbolique !

Pour créer un la variable a = 5 (donc qui a pour valeur un entier naturel), c'est assez facile.  
La variable contenant un entier naturel est composée ainsi : (en hexadécimal)
    * 1er octet : 0x00
    * 2ème octet : checksum, indique le nombre d'octet qu'il reste jusqu'à la fin du fichier (pour des vérifications)
    * n octets suivants : utilisés pour coder le nombre, on part du dernier octet composant le nombre en hexa.
    * octet suivant ces n octets : indique le nombre d'octets décrivant la valeur du nombre (pour des vérifications).
    * dernier octet : 0x1F, valeur pour les entiers naturels

Donc pour créer a = 5, il convient d'utiliser le code source suivant :

#define OPTIMIZE_ROM_CALLS
#define ENTIER_NATUREL_TAG 0x1F
#define CHECKSUM 0x3

#include <tigcclib.h>

short _ti89;

void _main(void)
{
  FILE *f;
  f = fopen("a", "wb");
  fputc(0, f);
  fputc(CHECKSUM, f);
  fputc(0x5, f);
  fputc(0x1, f);
  fputc(ENTIER_NATUREL_TAG, f);
  fclose(f);
}

    Je ne te pourrai pas t'aider beaucoup plus à ce sujet, mais, à mon avis, regarde un peu comment sont faites les variables avec un éditeur hexa : ça peut t'aider à comprendre pas mal de choses...

Merci aux personnes du forum de TI-Fr qui ont résolu cette question posées par l'un des visiteurs, et qui m'ont suggéré qu'elle pouvait avoir une place ici...


    Je voudrais apprendre quelques trucs permettant de créer des programmes nécessitant moins d'espace mémoire... autrement dit, je voudrais savoir comment optimiser mes programmes sur le point de vue Mémoire... Comment puis-je faire ?

    Tu veux créer des programmes occupant moins d'espace mémoire ? Eh bien, bon courage, tu vas t'amuser : la partie optimisation du programme au niveau de la mémoire est souvent la plus longue de tout le développement du programme !

    En fait, tu peux utiliser plusieurs astuces, qui te permettront d'utiliser moins d'espace mémoire :


    J'ai créé un petit programme, et, je ne comprend vraiment pas pourquoi, mais quand je l'utilises, j'ai de la mémoire RAM (entre 100 et 200 octets environ, à chaque utilisation du programme) qui disparaît... Certes, j'utilises de l'allocation dynamique de mémoire, mais je n'oublie pas de libérer les bloc alloués, comme expliqué dans le Chapitre XX. A quoi cela peut-il être du ??? (Mon programme ne fait pas grand chose : il affiche juste quelques graphismes et une boite de dialogue...)

    Avant de lire la réponse que je vais te donner juste après, vérifie, à toute fins utiles, que la mémoire qui disparaît n'est pas tout simplement utilisée pour l'historique de calculs : c'est tout bête, mais il est possible que ce soit ça, puisque, à sa sortie, le nom du programme est placé dans celui-ci... et que, comme la plupart des gens, tu n'y ai pas pensé. (Ne t'inquiète pas, ça m'est à moi aussi bien souvent arrivé de me demander où ces quelques octets étaient passés !!!).

    Maintenant, nous allons voir pourquoi, à mon avis, ton programme fait "disparaître" un peu de mémoire de la sorte...

    Tout d'abord, il faut que tu saches que le problème vient d'une forme d'allocation de mémoire. En effet, quand tu as créé ta boite de dialogue, tu lui a alloué un peu de mémoire, à travers à HANDLE, en faisant quelque chose qui ressemblait à ceci :
       HANDLE nom_de_le_bte_de_dlg = DialogNewSimple(largeur, hauteur);
    Le problème est qu'il faut libérer la mémoire allouée ainsi, de la même façon qu'il faut libérer celle qui est allouée avec la fonction malloc. Ici, étant donné que tu ne dispose pas d'un pointeur vers l'espace mémoire alloué, mais de son HANDLE, il conviendra d'utiliser l'instruction suivante :
        HeapFree(nom_de_le_bte_de_dlg);
    Cette instruction doit être utilisée une fois que tu n'as plus besoin de ta boite de dialogue :-) !

    Mais, si tu utilises aussi des menus de type PopUp dans ta boite de dialogue, tu peux remarquer que tu perd encore un peu de mémoire RAM, même si c'est à présent en plus faible quantité... Cela est du au fait que, pour les menus de type PopUp, tu as aussi alloué un HANDLE. Il te faudra donc le libérer une fois que tu n'en auras plus besoin, exactement de la même manière que pour les boites de dialogue...

    A présent, je penses que ton programme ne devrait plus te faire "perdre" de mémoire RAM (à part dans l'historique de calcul !)...

 



Cette page est en construction permanente... 

puisqu'elle recense des question que l'on me pose souvent...

Remerciements tout particulier à Kevin Kofler pour les nombreuses remarques qu'il m'a fait concernant cette page, afin de me permettre de l'améliorer...


Copyright Squale92 & Verstand. Logo et sigle TCI® réservés. Développé pour MS Internet Explorer 5.0 en 1024x768 pixels. Page modifiée le