Que sont la pile et le tas dans le langage Go ?

La pile est une structure de données, qui est l'espace mémoire réservé au thread d'exécution ; la pile permet uniquement de placer les données à une extrémité de la table linéaire, puis les données sont extraites à cette extrémité, c'est-à-dire dans l’ordre du premier entré, du dernier sorti, du dernier entré, du premier sorti de la pile. Le tas est une structure de données qui est un espace mémoire réservé à l'allocation dynamique ; contrairement à la pile, il n'y a pas de modèle fixe pour allouer et réaffecter les blocs du tas, vous pouvez l'allouer et le libérer à tout moment ;

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Pile et tas en langage Go

Il existe deux concepts très importants dans le langage de programmation, le tas et la pile

Le tas et la pile sont deux structures de données très importantes, qui sont souvent utilisées lors de l'édition de programmes.

Jetons un coup d'œil à ces deux structures de données.

Pile

La pile permet uniquement aux données d'être placées à une extrémité de la liste linéaire, puis les données sont supprimées à cette extrémité, c'est-à-dire que les éléments de la pile sont retirés dans l'ordre du premier entré, dernier sorti, dernier entré, premier sorti.

Le processus de mise en pile d'éléments s'appelle pousser. Pousser sur la pile augmentera le nombre d'éléments sur la pile. Le dernier élément placé dans la pile est en haut de la pile et le premier élément placé dans la pile est en bas de la pile.

Lorsque vous retirez des éléments de la pile, ils ne peuvent être retirés que du haut de la pile. Après avoir retiré des éléments, le nombre de piles deviendra plus petit. L'élément mis en premier est toujours retiré en dernier et l'élément est toujours retiré en dernier. mis en dernier est toujours retiré en premier.

Nous utilisons souvent des tableaux pour simuler l'utilisation d'une pile :

Le code d'implémentation pour pousser et faire éclater la pile est le suivant :

package main
import (
   "fmt"
   "errors"
)

//使用数组来模拟一个栈的使用
type Stack struct {

   MaxTop int       // 表示我们栈最大可以存放数个数
   Top int          // 表示栈顶, 因为栈顶固定，因此我们直接使用Top
   arr [5]int       // 用一个数组模拟栈
}

//入栈函数
func (this *Stack) Push(val int) (err error) {

   //先判断栈是否满了
   if this.Top == this.MaxTop - 1 {
      fmt.Println("stack full")
      return errors.New("stack full")
   }
   this.Top++
   //放入数据
   this.arr[this.Top] = val
   return
}

//出栈函数
func (this *Stack) Pop() (val int, err error) {
   //判断栈是否空
   if this.Top == -1 {
      fmt.Println("stack empty!")
      return 0, errors.New("stack empty")
   }

   //先取值，再 this.Top--
   val =  this.arr[this.Top]
   this.Top--
   return val, nil
}

//遍历栈，注意需要从栈顶开始遍历
func (this *Stack) List() {
   //先判断栈是否为空
   if this.Top == -1 {
      fmt.Println("stack empty")
      return
   }
   fmt.Println("栈的情况如下：")
   for i := this.Top; i >= 0; i-- {
      fmt.Printf("arr[%d]=%d\n", i, this.arr[i])
   }
}

func main() {

   stack := &Stack{
      MaxTop : 5,    // 表示最多存放5个数到栈中
      Top : -1,      // 当栈顶为-1，表示栈为空
   }

   //入栈
   stack.Push(1)
   stack.Push(2)
   stack.Push(3)
   stack.Push(4)
   stack.Push(5)
   stack.List()//显示

   //出栈
   val, _ := stack.Pop()
   fmt.Println("出栈val=", val)    // 5
   stack.List()                    //显示
}

Heap

Le tas dans l'allocation de mémoire est similaire à le placer dans une pièce Pour placer divers meubles, la taille des meubles peut être grande ou petite. Lors de l'allocation de la mémoire, vous devez trouver un espace suffisamment grand pour contenir les meubles avant de les placer.

Après avoir placé et libéré des meubles à plusieurs reprises, l'espace dans la pièce deviendra désordonné. À ce moment-là, si vous placez des meubles dans cet espace, vous constaterez que même s'il y a suffisamment d'espace, chaque espace est réparti dans différentes zones et il y en a. pas de section continue pour placer les meubles. À ce stade, l’allocateur de mémoire doit ajuster et optimiser ces espaces.

Comparé à la mémoire allouée au tas et à la mémoire allouée à la pile, le tas convient à l'allocation de mémoire de tailles imprévisibles.

Allocation du tas et de la pile

Une fois la définition de la variable terminée, elle est généralement allouée sur l'espace du tas et de la pile. L'espace existant dépend de l'existence ou non d'une allocation dynamique de mémoire (nouveau/malloc).

Par exemple, le cas suivant

Case 1

var p *int    //全局指针变量
func f(){
    var i int
    i = 1
    p = &i    //全局指针变量指向局部变量i
}

Case 2

func f(){
    p := new(int) //局部指针变量，使用new申请的空间
    *p = 1
}

Dans le premier cas, var est utilisé pour définir des variables locales, mais comme i est affecté à la variable de pointeur global p, lorsque la fonction se termine, je ne le ferai pas est libéré, donc la variable locale i est allouée sur le tas (libérée manuellement par le programmeur).

• Variable locale : variable définie dans une fonction, elle a un cycle de vie dynamique : une nouvelle entité est créée à chaque exécution, et elle survit jusqu'à ce que personne ne l'utilise (par exemple, aucun pointeur externe ne pointe vers elle, la fonction se termine Lorsqu'il n'y a pas de chemin pour accéder à cette variable), l'espace qu'elle occupe sera récupéré à ce moment-là

Dans le deuxième cas, new est utilisé pour demander de l'espace puisque p sera libéré après la sortie de la fonction, p. est appliqué sur la pile (libération automatique)

【Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!