Was sind Stack und Heap in der Go-Sprache?

Der Stapel ist eine Datenstruktur, bei der es sich um den für den Ausführungsthread reservierten Speicherplatz handelt. Der Stapel ermöglicht nur das Einfügen von Daten in ein Ende der linearen Tabelle und das Herausnehmen der Daten an diesem Ende, d. in der Reihenfolge „First in, Last out, Last in, First out“-Elemente im Stapel. Der Heap ist eine Datenstruktur, die einen für die dynamische Zuweisung reservierten Speicherplatz darstellt. Im Gegensatz zum Stapel gibt es kein festes Muster für die Zuweisung und Neuzuweisung von Blöcken aus dem Heap. Sie können ihn jederzeit zuweisen und freigeben.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Stack und Heap in der Go-Sprache

Es gibt zwei sehr wichtige Konzepte in der Programmiersprache: Heap und Stack.

Heap und Stack sind zwei sehr wichtige Datenstrukturen, die häufig beim Bearbeiten von Programmen verwendet werden.

Werfen wir einen Blick auf diese beiden Datenstrukturen.

Stapel

Der Stapel ermöglicht nur das Einfügen von Daten in ein Ende der linearen Liste, und dann werden die Daten an diesem Ende herausgenommen, dh die Elemente im Stapel werden in der Reihenfolge herausgenommen von First In, Last Out, Last In, First Out.

Der Vorgang, Elemente in den Stapel zu legen, wird Pushing genannt. Durch das Schieben auf den Stapel wird die Anzahl der Elemente auf dem Stapel erhöht. Das letzte in den Stapel gelegte Element befindet sich oben im Stapel und das erste in den Stapel gelegte Element befindet sich unten im Stapel.

Beim Herausnehmen von Elementen aus dem Stapel können diese nur von oben herausgenommen werden. Nach dem Herausnehmen von Elementen wird die Anzahl der Stapel kleiner. Das zuerst eingelegte Element wird immer als letztes herausgenommen Zuletzt eingelegt, wird immer zuerst herausgenommen. Wir verwenden häufig Arrays, um die Verwendung eines Stapels zu simulieren: Platzieren in einem Raum Um verschiedene Möbel zu platzieren, können die Möbel groß oder klein sein. Wenn Sie Speicher zuweisen, müssen Sie einen Raum finden, der groß genug ist, um die Möbel aufzunehmen, bevor Sie die Möbel platzieren.

Nach dem wiederholten Platzieren und Entleeren von Möbeln wird der Raum im Raum unordentlich. Wenn Sie zu diesem Zeitpunkt Möbel in diesem Raum platzieren, werden Sie feststellen, dass zwar genügend Platz vorhanden ist, jeder Raum jedoch auf verschiedene Bereiche verteilt ist Kein durchgehender Bereich zum Aufstellen von Möbeln. Zu diesem Zeitpunkt muss der Speicherzuweiser diese Räume anpassen und optimieren.

Im Vergleich zu Heap-zugewiesenem Speicher und Stapel-zugewiesenem Speicher eignet sich der Heap für die Speicherzuweisung unvorhersehbarer Größen.

Heap- und Stack-Zuweisung

Nachdem die Variablendefinition abgeschlossen ist, wird sie im Allgemeinen auf dem Heap- und Stack-Speicherplatz zugewiesen, abhängig davon, ob eine dynamische Speicherzuweisung erfolgt (neu/malloc).

Zum Beispiel der folgende Fall

Fall 1

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()                    //显示
}

Fall 2

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

Im ersten Fall wird var zum Definieren lokaler Variablen verwendet, aber da i der globalen Zeigervariablen p zugewiesen wird, wenn die Funktion endet, i wird nicht freigegeben, daher wird die lokale Variable i auf dem Heap zugewiesen (manuell vom Programmierer freigegeben).

Lokale Variable: eine in einer Funktion definierte Variable, sie hat einen dynamischen Lebenszyklus: Bei jeder Ausführung wird eine neue Entität erstellt und sie bleibt bestehen, bis sie niemand mehr verwendet (z. B. kein externer Zeiger darauf zeigt). Die Funktion wird beendet, wenn kein Pfad für den Zugriff auf diese Variable vorhanden ist. Der von ihr belegte Speicherplatz wird zu diesem Zeitpunkt zurückgefordert. Im zweiten Fall wird new verwendet, um Speicherplatz zu beantragen. Da p nach dem Beenden der Funktion freigegeben wird, p wird auf den Stapel angewendet (Automatische Freigabe)[Verwandte Empfehlungen:

Go-Video-Tutorial

,

Programmierunterricht

]

Das obige ist der detaillierte Inhalt vonWas sind Stack und Heap in der Go-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!