0Pricing
Swift Academy · Lektion

Unsichere Buffer-Pointer

Verarbeiten Sie zusammenhängenden Speicher effizient.

Unsichere Buffer-Pointer ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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 Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ein Buffer-Pointer ist

Ein einzelner typisierter Zeiger adressiert jeweils ein Element. Ein UnsafeBufferPointer<T> kapselt einen Startzeiger plus eine Anzahl und stellt Ihnen damit eine begrenzte Sicht auf einen zusammenhängenden Speicherblock bereit, der dem Protokoll Collection entspricht.

Das bedeutet, dass Sie iterieren, per Subscript zugreifen, mappen und reduzieren können – alle vertrauten Collection-APIs über dem Rohspeicher.

// A buffer pointer = base address + element count
// UnsafeBufferPointer<Int>(start: ptr, count: 5)

Schreibgeschützte und veränderbare Buffer

Wie einzelne Zeiger gibt es Buffer in zwei Varianten: UnsafeBufferPointer<T> für die schreibgeschützte Iteration und UnsafeMutableBufferPointer<T>, wenn Sie zusätzlich Elemente zuweisen müssen.

let p = UnsafeMutablePointer<Int>.allocate(capacity: 4)
p.initialize(repeating: 0, count: 4)
let buf = UnsafeMutableBufferPointer(start: p, count: 4)
buf[0] = 11
print(buf[0]) // 11

Wie bei einer Collection iterieren

Da ein Buffer-Pointer eine Collection ist, durchläuft eine for-Schleife jedes Element der Reihe nach. Keine manuelle Indexarithmetik, kein Off-by-one-Risiko in der Schleife selbst – allerdings sind die von Ihnen angegebenen Grenzen weiterhin Ihre Verantwortung.

let buf = UnsafeMutableBufferPointer<Int>.allocate(capacity: 3)
_ = buf.initialize(from: [10, 20, 30])
for value in buf { print(value) } // 10, 20, 30

Collection-Algorithmen ohne Zusatzaufwand

map, filter, reduce, enumerated und indices funktionieren mit Buffer-Pointern. So können Sie Rohspeicher mit High-Level-Code verarbeiten und dabei ohne Speicherallokationen auskommen.

let buf = UnsafeMutableBufferPointer<Int>.allocate(capacity: 4)
_ = buf.initialize(from: [1, 2, 3, 4])
let total = buf.reduce(0, +)   // 10
let evens = buf.filter { $0 % 2 == 0 } // [2, 4]
print(total, evens)

Einen veränderbaren Buffer allozieren

UnsafeMutableBufferPointer<T>.allocate(capacity:) reserviert den Speicherblock und gibt in einem Schritt einen Buffer zurück. Sie müssen dennoch vor dem Lesen initialize aufrufen und nach Abschluss deallocate aufrufen.

let buf = UnsafeMutableBufferPointer<Int>.allocate(capacity: 5)
buf.initialize(repeating: 0)
defer {
    buf.deinitialize()
    buf.deallocate()
}

Grenzen werden nicht automatisch geprüft

Der Zugriff per Subscript innerhalb von 0..<count ist in Ordnung. Der Buffer kann jedoch nicht wissen, ob die von Ihnen angegebene Anzahl korrekt war. Wenn Sie einen Buffer mit einer größeren Anzahl als die tatsächliche Allokation erstellen, laufen Lesezugriffe über das Ende hinaus in undefinierten Speicher.

Leiten Sie die Anzahl immer aus derselben Allokation ab, die Sie erstellt haben.

let p = UnsafeMutablePointer<Int>.allocate(capacity: 3)
p.initialize(repeating: 0, count: 3)
// CORRECT: count matches capacity
let good = UnsafeBufferPointer(start: p, count: 3)
// WRONG: count: 10 would read past the block
print(good.count)

Leere Buffer

Ein Buffer mit count: 0 ist gültig und kann eine nil-Basisadresse haben. Prüfen Sie immer isEmpty oder verlassen Sie sich darauf, dass die Schleife einfach nicht ausgeführt wird, statt baseAddress per Force-Unwrap zu entpacken.

let empty = UnsafeBufferPointer<Int>(start: nil, count: 0)
print(empty.isEmpty)       // true
print(empty.count)         // 0
for _ in empty { print("never runs") }

withUnsafeBufferPointer bei Arrays

Die sicherste Möglichkeit, einen Buffer zu erhalten, besteht darin, ihn über withUnsafeBufferPointer aus einem vorhandenen Array zu beziehen. Swift garantiert, dass der Speicher zusammenhängend und für die Dauer der Closure gültig ist; so vermeiden Sie manuelle Allokation vollständig.

let numbers = [4, 8, 15, 16, 23]
let maxValue = numbers.withUnsafeBufferPointer { buf -> Int in
    var m = buf[0]
    for v in buf where v > m { m = v }
    return m
}
print(maxValue) // 23

Array-Speicher verändern

withUnsafeMutableBufferPointer ermöglicht es Ihnen, direkt in den Speicher eines Arrays zu schreiben. Dies wird gelegentlich für performancekritische In-Place-Transformationen verwendet, bei denen ARC und Grenzprüfungen zusätzlichen Overhead verursachen würden.

var data = [1, 2, 3, 4]
data.withUnsafeMutableBufferPointer { buf in
    for i in buf.indices { buf[i] *= 10 }
}
print(data) // [10, 20, 30, 40]

baseAddress für C-APIs

Wenn Sie eine C-Funktion aufrufen, die einen Zeiger sowie eine Länge erwartet, übergeben Sie buffer.baseAddress und buffer.count. Die Basisadresse ist nur bei leeren Buffern nil; behandeln Sie diesen Fall entsprechend.

let bytes: [UInt8] = [0xDE, 0xAD, 0xBE, 0xEF]
bytes.withUnsafeBufferPointer { buf in
    if let base = buf.baseAddress {
        // c_function(base, buf.count)
        print("start:", base, "len:", buf.count)
    }
}

Wann Sie Buffer-Pointer verwenden sollten

Verwenden Sie Buffer-Pointer, wenn Sie zusammenhängenden, typsicheren Zugriff im Collection-Stil auf einen Speicherbereich benötigen: zum Anbinden von C-Arrays, Parsen von Binärformaten oder um in heißen Schleifen Overhead einzusparen. Bevorzugen Sie nach Möglichkeit die Closure-Varianten mit with... gegenüber manueller Allokation.

// Counting set bits across a byte buffer
let data: [UInt8] = [0b1011, 0b0110, 0b1111]
let bits = data.withUnsafeBufferPointer { buf in
    buf.reduce(0) { $0 + $1.nonzeroBitCount }
}
print(bits) // 3 + 2 + 4 = 9

Schnelltest

Rufen Sie sich in Erinnerung, welchen zusätzlichen Nutzen ein Buffer-Pointer gegenüber einem einzelnen Zeiger bietet.

Zusammenfassung

Buffer-Pointer kapseln einen zusammenhängenden Bereich als begrenzte Collection:

  • UnsafeBufferPointer / UnsafeMutableBufferPointer = Basisadresse + Anzahl.
  • Sie erhalten map, filter, reduce und die Iteration mit for über dem Rohspeicher.
  • Bevorzugen Sie bei Arrays withUnsafeBufferPointer, damit Swift Gültigkeit und Lebensdauer verwaltet.
  • Die angegebene Anzahl wird als korrekt angenommen – leiten Sie sie aus der tatsächlichen Allokation ab.

Häufig gestellte Fragen

Ist die Lektion „Unsichere Buffer-Pointer“ kostenlos?

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

Was lerne ich in „Unsichere Buffer-Pointer“?

Verarbeiten Sie zusammenhängenden Speicher effizient. Du übst Swift 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 Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift 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 3 von 4.

Wie lange dauert die Lektion „Unsichere Buffer-Pointer“?

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 Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift 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

  1. MemoryLayout und Ausrichtung
  2. UnsafePointer und UnsafeMutablePointer
  3. Unsichere Buffer-Pointer
  4. withUnsafeBytes und C-Interop
← Zurück zu Swift Academy