Home   Archives    Hardware   Programmation   Challenges   Forum   Le Mag    Faq   La Communauté   L'Equipe
 
L'équipe progG de Ti-Fr

Voici les nicks de vos serviteurs ;-)

chickensaver_john
Kevin Kofler
Thibaut
janjan2
TiMad
Iceman89
fréka
Zewoo
Squale92
Verstand
ZdRUbAl
UtOpIaH

et nEUrOne ...

Une idée ?
Une idée pour améliorez cette partie? ou tout simplement vous souhaitez participer à l'élaborations des tutos.
Mailez-nous ici

Les raccourcis
 

Chapitre XX


    Nos TI-92plus et TI-89 disposent d'un Stack d'une contenance de 16ko. Quand vous créez des variables à l'intérieur d'une fonction (c'est-à-dire des variables qui ne soient pas globales), par exemple en utilisant le type d'instruction suivant, ces variables sont allouées sur ce Stack :
        unsigned short ma_var=0;
    Certes, pour des petites variables, ne pesant que quelques octets, on peut considéré que le Stack n'a aucun risque d'être trop petit ! Mais, comme nous le verrons bientôt, certaines fonctions nécessitent des variables de taille bien plus grosse... Dans de tels cas, il peut y avoir un risque de dépassement de cet espace mémoire, et le résultat visible sera généralement un plantage de la TI.
    De plus, il faut savoir que, quand vous créez des variables globales pour votre programme, celles-ci sont stockées dans le programme... et augmentent donc sa taille de façon considérable !!!

    Dans ce Chapitre, nous verrons comment utiliser la grande quantité de mémoire RAM dont dispose la TI pour stocker des variables dont la taille est trop importante pour qu'elles soient allouées sur la Stack ou dans le programme lui-même. Cette technique, qui consiste à placer les données en RAM est nommé "Allocation dynamique de Mémoire".

 

I:\ Les fonctions à connaître indispensablement pour utiliser la technique d'Allocation dynamique de mémoire :

        A: Allocation de la Mémoire :

    Il existe une fonction qui permet de réserver une certaine quantité de mémoire dans la RAM afin de l'utiliser ensuite. Cette fonction doit être utilisée avec la syntaxe suivante :
        malloc(taille_de_mem_a_allouer);
    Cette fonction prend en argument une valeur de type unsigned long, qui correspond à l'espace mémoire qu'elle devra allouer en RAM, exprimé en nombre d'octets. Elle renvoie un pointeur de type void * correspondant à l'espace mémoire nouvellement alloué. (Si jamais il n'existe pas assez d'espace en RAM pour allouer la quantité demandé, cette fonction renverra NULL).
    Cette fonction est un alias de la fonction spécifique du TIOS nommée HeapAllocPtr, mais c'est sous la forme malloc que nous la préférerons, par habitude. En effet, ce nom correspond à celui qu'elle porte sous d'autres machines (PC en particulier !). Cela signifie que si vous voyez la fonction HeapAllocPtr dans un source, il vous faudra comprendre qu'elle a exactement la même signification que malloc !

    Prenons à présent un exemple : imaginons que nous voulons allouer dynamiquement une chaîne de caractères de 100 caractères de long. Le problème est ici que nous avons dit que la fonction malloc retournait un pointeur de type void *, et non de type char *. Il nous faudra donc utiliser une petite manipulation, nommé "type casting", qui nous permet, en C, de passer d'un type de variable à un autre, de façon relativement simple. Voilà à quoi devra ressembler notre portion de source :
        char *chaîne_de_caracteres = (char *)malloc(100);    // Puisque chaque caractère dans une variable de type char fait un octet.

    Si vous souhaitez allouer de la mémoire RAM pour un type de donnée dont vous ignorez la taille de chaque élément, il vus faudra utiliser la commande sizeof. En reprenant l'exemple précédent, et en supposant que vous ignorez combien d'octet occupe chaque caractère dans une variable de type char, il faudrait utiliser ceci :
        char *chaîne_de_caracteres = (char *)malloc(100 * sizeof(char));    // Puisque chaque caractère dans une variable de type char fait un octet.
   La commande sizeof, qui est ici utilisée, prend en argument le type dont vous souhaitez connaître la taille, et renvoie celle-ci.

        B: Libération de la mémoire :

    Pour vous donner une idée de l'importance de libérer la mémoire allouée dynamiquement, vous pouvez réaliser cette succession d'opérations :

  • Regardez sur votre TI la quantité de mémoire RAM libre, et faites en sorte de vous rappeler de cette valeur.
  • Créez un programme effectuant l'allocation dynamique d'une forte quantité de mémoire par exemple, en allouant, comme dans la première partie de ce I, une chaîne de caractères, mais beaucoup plus longue que 100 octets).
  • Retournez voir la quantité de RAM disponible sur votre TI.
  • Comme vous pouvez le remarquer, cette quantité à diminuée ! En effet, la mémoire moire qui a été allouée dynamiquement par le programme doit être libérée en fin de programme (ou, du moins, quand elle n'a plus à être utilisée !). Dans le cas contraire, seul un RESET pourra libérer cet espace mémoire... Avouez que c'est plutôt gênant !

    Pour libérer l'espace mémoire alloué avec malloc, il convient d'utiliser la fonction suivante :
        free(pointeur);
    Cette fonction prend en argument le pointeur retourné par malloc lors de l'allocation.
    Cette fonction est un alias de la fonction spécifique du TIOS nommée HeapFreePtr, mais c'est sous la forme free que nous la préférerons, par habitude. En effet, ce nom correspond à celui qu'elle porte sous d'autres machines (PC en particulier !). Cela signifie que si vous voyez la fonction HeapFreePtr dans un source, il vous faudra comprendre qu'elle a exactement la même signification que free !

 

II:\ Avantages et inconvénients de l'allocation dynamique de mémoire :

    La technique d'allocation dynamique de mémoire que nous venons d'étudier présente plusieurs avantages et inconvénients :

  • Avantages :
    • Cette technique permet d'utiliser des variables de grande taille, arrivant à un total supérieur à 16ko, ce qui ne tiendrait pas sur le stack.
          Nous verrons dans le Chapitre suivant l'emploi d'allocation dynamique de mémoire pour l'utilisation d'écrans virtuels.
    • Cette technique permet d'allouer la quantité de mémoire dont nous souhaitons disposer que pour la durée pendant laquelle nous en avons besoin : il suffit par la suite de libérer cet espace mémoire.
    • Cette technique permet d'utiliser de grosses variables globales sans augmenter la taille du programme de façon importante.
  • Inconvénients :
    • Il ne faut pas oublier de libérer l'espace mémoire qui avait été alloué.
    • Il faut savoir de combien d'espace mémoire on aura exactement besoin, afin de ne pas allouer moins de mémoire que nécessaire pour les variables que nous utiliserons. (Pour cela, il peut être parfois possible d'utiliser la fonction sizeof, mais pas dans tous les cas...).

Retour au menu général

Chapitre XXI


 


Copyright © Ti-Fr v2.0 1999-2002