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 le x inclus dans la fonction disparaît une fois la fonction terminée, il va l'allouer à nouveau, il devrait disparaître, vous voulez qu'il disparaisse. Mais chaque fois que vous ne la désallouez pas, vous exécuterez, chaque fois que vous exécuterez cette fonction f, une nouvelle variable X vous sera allouée et vous aurez donc tous ces espaces alloués en mémoire et vous n'en avez vraiment plus besoin, n'est-ce pas ? Je veux dire qu'une fois qu'un appel de fonction particulier est terminé, vous n' avez plus besoin de l'espace pour le X qu'il utilisait. Donc, à un moment donné, vous devez désallouer cette mémoire. Vous devez dire « Écoutez, cette mémoire est maintenant libre », car sinon vous finirez par utiliser tout votre espace et vous pourriez vous demander : comment vais-je l'utiliser ? Mon espace ? J'ai X Go dans mon système de mémoire. Vous pouvez le manger très rapidement et croyez-moi, cela s'appelle une fuite de mémoire. C'est quelque chose qui se produit souvent en C. Vous pouvez occuper tout votre espace très rapidement. Vous devez donc désallouer cet espace en temps opportun. Maintenant, pour parler de la façon dont l'espace est déalloué, nous devons parler un peu de l'endroit où l'espace est stocké en mémoire. La mémoire est donc un élément important, mais il y a deux grandes parties de la mémoire qui nous intéressent en ce moment, la pile et le tas. Désormais, la pile est une zone de mémoire dédiée aux appels de fonction, 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. Ils sont alloués dans la zone de pile de la mémoire et sont désalloués. S'ils sont alloués dans la pile, ils sont désalloués automatiquement lorsque la fonction est terminée. Maintenant, c'est un peu différent pour Go. C'est traditionnel. Ce dont je parle maintenant, c'est de la façon dont cela fonctionne dans les langues ordinaires. Va changer ça un peu, d'accord. Mais normalement, la pile est la zone de ces variables locales où, lorsque la fonction est exécutée, 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. Ce tas de mémoire, vous devez le désallouer explicitement d'une manière ou d'une autre dans une autre langue. Donc, si vous étiez en C, par exemple, vous devriez le désallouer explicitement. Maintenant, Go fait un ajustement à ce sujet. Mais il est tout de même important de comprendre que les variables de mémoire peuvent se trouver dans la pile qui, pour la plupart, disparaîtra automatiquement lorsque la variable sera désallouée automatiquement lorsque la fonction est exécutée ou dans le tas où elle est persistante. Maintenant, si vous parlez une autre langue comme le C, vous devez désallouer manuellement les éléments sur le tas. Les éléments qui se trouvent sur la pile, vous n'avez pas à les désallouer manuellement, ils disparaîtront une fois la fonction terminée. Mais pour ce qui est du tas, vous devez le désallouer manuellement de manière explicite. Donc, supposons que vous travailliez en C, si vous voulez allouer de la mémoire sur le tas, vous appelleriez une fonction appelée malloc, et je dis que X est égal à malloc 32. Il allouera 32 octets de mémoire et X y sera affecté, puis plus tard, quand je le serai, c'est ainsi que vous l'allouerez. Plus tard, quand je voudrais le libérer, je dirais Free X et cela libérera cet espace en le désalloquant. Donc, sujet aux erreurs mais rapide. Donc, ce que je veux dire par là, c'est qu'il 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 le 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. Les mises en œuvre sont très rapides. Ce qui se passe avec la désallocation dans un langage interprété, c'est que l'interprète le fait correctement, ce qui peut prendre du temps. Donc, mais dans un langage compilé comme le C , vous devrez le faire manuellement.

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