|
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
|
| |
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
|
|