Nous avons parlé des variables et de la façon dont elles sont référencées. Les variables sont des labels qui font référence à des données qui se trouvent quelque part en mémoire. Vos variables devront éventuellement être allouée/désallouées en mémoire.

Une fois que vous avez déclaré une variable et que votre code est exécuté, un espace doit être alloué quelque part en mémoire pour cette variable. S'il s'agit d'un entier, un espace doit être alloué pour contenir cet entier et, à un moment donné, cet espace pourra être désalloué : une fois que son usage n'est plus nécessaire.

Ainsi, lorsque vous aurez fini d'utiliser votre variable X, vous voudrez pouvoir dire « Oh, cet espace est maintenant libre et il peut être utilisé à d'autres fins ». C'est donc de la désallocation, lorsque vous libérez de l'espace mémoire à d'autres fins.

Vous devez le faire au bon moment. Sinon vous finirez par manquer de mémoire et votre machine.

func f() {
   var x = 4
   fmt.Printf("%d", x)
}

Ainsi, dans l' exemple ci-dessus, on déclare une variable x. A l'exécution, le processus doit allouer un emplacement mémoire juste pour que x puisse contenir la valeur 4. Supposons maintenant que votre programme appelle cette fonction f() 100 fois, alors il allouera 100 espaces différents pour chaque variable x, parce que x est incluse dans la fonction et disparaît une fois la fonction terminée.

Sans désallocation à chaque exécution de la fonction f(), une nouvelle variable x serait allouée et vous auriez tous ces espaces alloués en mémoire alors que vous n'en avez plus vraiment besoin. En effet, une fois qu'un appel de la fonction est terminé, vous n' avez plus besoin de l'espace que x utilisait en interne pour le traitement la fonction. Donc, à un moment donné, vous devez désallouer cette mémoire.

On doit pouvoir désigner cette mémoire comme maintenant libre, car sinon même si l'espace mémoire est grand il peut être très rapidement consommé. Cela s'appelle une fuite de mémoire et c'est une défaut que l'on rencontre souvent en C.

Vous pouvez occuper tout votre espace mémoire très rapidement, vous devez donc désallouer cet espace en temps opportun.

Maintenant, pour parler de la façon dont l'espace est alloué/déalloué, nous devons parler un peu de la façon dont les données sont stockées en mémoire. La mémoire est donc un espace étendu, mais il y a deux grandes parties qui nous intéressent en ce moment, la pile (stack) et le tas (heap).

La pile est une zone de mémoire principalement dédiée aux appels de fonction. Ainsi, l'une des choses stockées dans la pile sont les variables locales d'une fonction. Ainsi, chaque fois que vous appelez une fonction, vous pouvez définir des variables dans cette fonction et elles entrent généralement dans la pile. Ces variables alloués dans la pile sont désalloués automatiquement lorsque la fonction est terminée.

Ce type de gestion des variables dans la pile est celui utilisé traditionnellement par les langages, c'est un peu différent pour Go. Mais normalement, dans pile, après exécution de la fonction, les variables sont désallouées automatiquement.

Le tas, en revanche, est une région persistante de mémoire où, lorsque vous allouez un élément sur le tas, il ne disparaît pas simplement parce que la fonction qui l'a alloué est terminée. Dans le cas du tas (pour la plupart des autres langages) vous devez désallouer explicitement d'une manière ou d'une autre vos éléments. Donc, si vous étiez en C, par exemple, vous devriez le désallouer explicitement.

Notons que Go fonctionne un peu différemment mais il est tout de même important de comprendre que les variables peuvent se trouver :

• Dans la pile et sont désallouée automatiquement après exécution de la fonction dans la plupart des langages ;
• Dans le tas où elle sont persistantes.

Donc, supposons que vous travailliez en C, et que vous vouliez allouer de la mémoire sur le tas :

x = malloc(32);
 
free(x);

Vous appelleriez une fonction appelée malloc(). Elle alloue dans l'extrait ci-dessus 32 octets de mémoire qui seront affectés à x, puis plus tard, quand vous voudrez les libérer, vous utiliserez free(X) et cela libérera cet espace en le désallouant.

Ce mode de fonctionnement est sujet aux erreurs mais rapide. C'est sujet aux erreurs car il est facile de se tromper dans votre allocation et votre désallocation. Désallouer au mauvais moment ou oublier de désallouer, ce genre de choses peut provoquer des maux de tête. C'est donc sujet aux erreurs dans ce sens, mais c'est rapide.

Dans le cas des langages interprétés, c'est l'interprète qui alloue/désalloue, il le fait correctement, ce qui peut prendre du temps. Mais dans un langage compilé comme le C, vous devrez le faire manuellement.

◁ Précédent | ⌂ Retour au sommaire | Suivant ▷