Antwort.

In Go werden Strukturen (struct) standardmäßig nach Wert übergeben und zurückgegeben. Das bedeutet, dass beim Aufruf einer Funktion oder bei der Rückgabe aus dieser die gesamte Struktur kopiert wird. Für kleine Strukturen ist das transparent, aber bei großen ist die Frage kritisch.

Hintergrund

Ursprünglich war Go auf eine effiziente Arbeit mit einer geringen Anzahl von Allokationen ausgerichtet. Das Risiko unbewusster Kopieroperationen großer Daten stellte sich ein, als Strukturen viele Felder und verschachtelte Objekte verwendeten. Die Leistung solcher Operationen kann leiden, und manchmal zeigt sich der Unterschied nur bei Profilierungen oder durch Probleme mit dem GC.

Problem

Wenn eine Struktur groß ist, ist das Kopieren bei jedem Funktionsaufruf, der Rückgabe oder Zuweisung kostspielig. Dies führt zu:

einer Erhöhung der Ausführungszeit;
einer Belastung des GC (Copy-on-Write für große Felder, Verzögerung der Speicherbereinigung);
Fehlern, wenn Änderungen, die an der Kopie vorgenommen wurden, nicht in das Original gelangen.

Lösung

Für große Strukturen wird empfohlen, einen Zeiger auf die Struktur (*T) und nicht das Objekt selbst zu übergeben und zurückzugeben. Dies reduziert die Overheads und ermöglicht die Arbeit mit einer einzigen Instanz der Daten.

Beispielcode:

package main
import "fmt"

type Large struct {
    Data [1024]int
}

// Übergabe nach Wert (nicht korrekt für große Objekte)
func ValueProcess(l Large) {
    l.Data[0] = 123 // ändert nur die Kopie
}

// Übergabe per Zeiger
func PointerProcess(l *Large) {
    l.Data[0] = 456 // ändert das Original
}

func main() {
    a := Large{}
    ValueProcess(a)
    fmt.Println("Nach ValueProcess:", a.Data[0]) // 0
    PointerProcess(&a)
    fmt.Println("Nach PointerProcess:", a.Data[0]) // 456
}

Wesentliche Merkmale:

Alle Strukturen werden standardmäßig nach Wert kopiert;
Die Übergabe der Adresse (Zeiger) vermeidet das Kopieren;
Die Rückgabe nach Wert kann vom Compiler für kleine Strukturen effizient optimiert werden, aber nicht für große.

Fangfragen.

1. Kann ein Zeiger auf eine lokale Struktur-Variable aus einer Funktion in Go zurückgegeben werden?

Ja. Go garantiert die Gültigkeit solcher Zeiger, indem es automatisch die Werte in den Heap verschiebt, auf die der Zeiger zurückgegeben wird (Escape to heap).

func NewLarge() *Large {
    l := Large{}
    return &l
}

2. Wird das Original ändern, wenn eine Struktur nach Wert an die Funktion übergeben und die Felder darin geändert werden?

Nein: nur die Kopie wird geändert, und das Original bleibt außerhalb der Funktion unverändert.

3. Soll immer ein Zeiger für Strukturen verwendet werden?

Nein. Für kleine Strukturen (mit wenigen Feldern) ist die Übergabe nach Wert sicher und oft vorzuziehen (immutable/value-semantic), da sie Allokationen spart und die Belastung des GC reduziert.

Typische Fehler und Anti-Muster

Rückgabe großer Strukturen und deren Übergabe an Funktionen nach Wert ohne Notwendigkeit;
Unbegründete Verwendung von Zeigern für triviale Structs;
Fehler in der Änderbarkeit von Daten: versehentliche Aktualisierung nur der Kopie und nicht des Originals.

Praxisbeispiel

Negativer Fall

In einem Logging-Service stellte jedes Ereignis eine große Struktur dar und wurde aus Funktionen nach Wert zurückgegeben — jede Änderung kopierte die Struktur vollständig.

Vorteile:

Der Code war einfach und sicher für kleine Strukturen.

Nachteile:

Der Speicherverbrauch stieg, der GC wurde häufig aktiv, der Service begann zu stocken.

Positiver Fall

Wir wechselten zu der Übergabe und Rückgabe von Strukturen per Zeiger, indem wir Daten über Signaturen wie func(l *Large) und func() *Large änderten.