Go Academy · Lektion

Pointer und Funktionen

Übergabe per Wert gegenüber Übergabe per Pointer

Pointer und Funktionen ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Übergabe per Wert

Go übergibt alle Funktionsargumente per Wert — es wird eine Kopie erstellt. Änderungen innerhalb der Funktion wirken sich nicht auf das Original aus:

package main
import "fmt"

func increment(n int) { n++ }

func main() {
    x := 5
    increment(x)
    fmt.Println(x) // 5 — unchanged
}

Übergabe per Pointer

Übergeben Sie einen Pointer, damit die Funktion das Original ändern kann:

package main
import "fmt"

func increment(n *int) { *n++ }

func main() {
    x := 5
    increment(&x)
    fmt.Println(x) // 6
}

Pointer zurückgeben

Funktionen können Pointer auf im Heap allozierte Werte zurückgeben. Die Escape-Analyse von Go sorgt für Sicherheit:

package main
import "fmt"

func newInt(v int) *int { return &v }

func main() {
    p := newInt(42)
    fmt.Println(*p) // 42
}

Effizienz bei großen Structs

Die Übergabe eines großen Structs per Pointer vermeidet eine aufwendige Kopie:

package main
import "fmt"

type BigData struct{ Data [1024]int }

func process(d *BigData) { d.Data[0] = 99 }

func main() {
    bd := BigData{}
    process(&bd)
    fmt.Println(bd.Data[0]) // 99
}

Pointer auf ein Interface

Nur selten erforderlich – Interfaces enthalten intern bereits einen Pointer. Die Übergabe von *interface{} ist fast immer falsch:

package main
import "fmt"

type Stringer interface{ String() string }

func print(s Stringer) { fmt.Println(s.String()) }

// Pass interface directly, NOT *Stringer
type Name string
func (n Name) String() string { return string(n) }

func main() {
    print(Name("Alice"))
}

Optionale Parameter mit Pointern

Verwenden Sie Pointer-Parameter, um zwischen „nicht angegeben“ und dem Nullwert zu unterscheiden:

package main
import "fmt"

func greet(name *string) {
    if name == nil {
        fmt.Println("Hello, stranger")
        return
    }
    fmt.Println("Hello,", *name)
}

func main() {
    s := "Alice"
    greet(&s)
    greet(nil)
}

Ändern über Slices

Slices enthalten bereits einen internen Pointer, daher benötigen Sie häufig keinen *[]T. Wenn append jedoch neu alloziert, benötigen Sie einen Pointer auf den Slice selbst:

package main
import "fmt"

func addItem(s *[]int, v int) { *s = append(*s, v) }

func main() {
    nums := []int{1, 2, 3}
    addItem(&nums, 4)
    fmt.Println(nums) // [1 2 3 4]
}

Pointer-Aliasing

Mehrere Pointer auf dieselbe Variable erzeugen Aliasing – eine Änderung über einen Pointer ist über alle anderen sichtbar:

package main
import "fmt"

func main() {
    x := 10
    a, b := &x, &x
    *a = 99
    fmt.Println(*b) // 99 — same memory
}

Übermäßige Verwendung von Pointern vermeiden

Verwenden Sie Pointer nur, wenn sie erforderlich sind:

Änderungen innerhalb einer Funktion
Große Structs (>= ca. 64 Byte)
Nil als Kennzeichnung für „nicht vorhanden“

Eine übermäßige Verwendung von Pointern erhöht den Druck auf den GC und verringert die Klarheit des Codes.

Muster für Funktions-Pointer

Speichern Sie Funktions-Pointer in einer Map für Dispatch-Tabellen:

package main
import "fmt"

func add(a, b int) int { return a + b }
func sub(a, b int) int { return a - b }

func main() {
    ops := map[string]func(int,int)int{
        "+": add, "-": sub,
    }
    fmt.Println(ops["+"](10, 3)) // 13
    fmt.Println(ops["-"](10, 3)) // 7
}

Kurztest

Wie ermöglichen Sie es einer Funktion, eine Integer-Variable zu ändern, die im aufrufenden Code definiert ist?

Zusammenfassung

Wichtige Erkenntnisse:

Go verwendet Wertübergabe – verwenden Sie Pointer zum Ändern von Werten
Geben Sie aus Konstruktoren Pointer zurück, um eine Allokation auf dem Heap zu erreichen
Slices enthalten einen internen Pointer, aber append kann *[]T erforderlich machen
Vermeiden Sie eine übermäßige Verwendung von Pointern – bevorzugen Sie Werte für kleine Typen

Übungsaufgabe

Schreiben Sie eine normalize-Funktion, die *[]string entgegennimmt und mithilfe von strings.ToLower alle Strings direkt im Slice in Kleinbuchstaben umwandelt.

Häufig gestellte Fragen

Ist die Lektion „Pointer und Funktionen“ kostenlos?

Ja — der vollständige Text von „Pointer und Funktionen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Pointer und Funktionen“?

Übergabe per Wert gegenüber Übergabe per Pointer Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Pointer und Funktionen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy