Unsafe buffer pointers
Verwerk aaneengesloten geheugen efficiënt.
Unsafe buffer pointers is een gratis Swift Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Swift Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Swift Academy bevat in totaal 4 lessen.
Wat een bufferpointer is
Een enkele getypeerde pointer wijst telkens naar één element. Een UnsafeBufferPointer<T> omsluit een startpointer plus een aantal, zodat je een begrensde weergave krijgt van een aaneengesloten geheugenblok dat voldoet aan Collection.
Dat betekent dat je kunt itereren, via subscripts elementen kunt benaderen, map en reduce kunt gebruiken — alle vertrouwde API's voor collecties op onbewerkt geheugen.
// A buffer pointer = base address + element count
// UnsafeBufferPointer<Int>(start: ptr, count: 5)Alleen-lezen en wijzigbare buffers
Net als losse pointers bestaan buffers in twee varianten: UnsafeBufferPointer<T> voor iteratie in alleen-lezenmodus en UnsafeMutableBufferPointer<T> wanneer je ook elementen moet toewijzen.
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]) // 11Itereren als een collectie
Omdat een bufferpointer een Collection is, doorloopt een for-lus elk element in volgorde. Geen handmatige berekening van indices en geen risico op een off-by-one-fout in de lus zelf — al blijven de grenzen die je hebt opgegeven wel jouw verantwoordelijkheid.
let buf = UnsafeMutableBufferPointer<Int>.allocate(capacity: 3)
_ = buf.initialize(from: [10, 20, 30])
for value in buf { print(value) } // 10, 20, 30Gratis collectie-algoritmen
map, filter, reduce, enumerated en indices werken allemaal op bufferpointers. Zo kun je onbewerkt geheugen met code op hoog niveau verwerken zonder geheugenallocaties.
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)Een wijzigbare buffer alloceren
UnsafeMutableBufferPointer<T>.allocate(capacity:) reserveert het blok en geeft in één stap een buffer terug. Je moet nog steeds initialize uitvoeren voordat je gaat lezen en deallocate aanroepen wanneer je klaar bent.
let buf = UnsafeMutableBufferPointer<Int>.allocate(capacity: 5)
buf.initialize(repeating: 0)
defer {
buf.deinitialize()
buf.deallocate()
}Grenzen worden niet automatisch gecontroleerd
Indexeren binnen 0..<count is prima. Maar de buffer kan niet weten of het aantal dat je hebt opgegeven correct was. Als je een buffer maakt met een aantal dat groter is dan de echte allocatie, lopen leesbewerkingen voorbij het einde door naar ongedefinieerd geheugen.
Leid het aantal altijd af van dezelfde allocatie die je hebt gemaakt.
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)Lege buffers
Een buffer met count: 0 is geldig en kan een nil-basisadres hebben. Controleer altijd isEmpty of vertrouw erop dat de lus eenvoudigweg niet wordt uitgevoerd, in plaats van baseAddress geforceerd uit te pakken.
let empty = UnsafeBufferPointer<Int>(start: nil, count: 0)
print(empty.isEmpty) // true
print(empty.count) // 0
for _ in empty { print("never runs") }withUnsafeBufferPointer op arrays
De veiligste manier om een buffer te krijgen, is via een bestaande Array met withUnsafeBufferPointer. Swift garandeert dat de opslag aaneengesloten en geldig is zolang de closure duurt, zodat je handmatige allocatie volledig vermijdt.
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) // 23Array-opslag wijzigen
Met withUnsafeMutableBufferPointer kun je rechtstreeks naar de opslag van een array schrijven. Dit wordt soms gebruikt voor prestatiekritische transformaties die ter plaatse worden uitgevoerd, waarbij ARC en grenscontroles extra overhead zouden veroorzaken.
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 voor C-API's
Wanneer je een C-functie aanroept die een pointer plus lengte verwacht, geef je buffer.baseAddress en buffer.count door. Het basisadres is alleen nil voor lege buffers, dus handel dat geval af.
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)
}
}Wanneer je bufferpointers gebruikt
Gebruik bufferpointers wanneer je aaneengesloten, typeveilige toegang in collectiestijl tot een geheugengebied nodig hebt: C-arrays overbruggen, binaire indelingen parsen of overhead in hete lussen wegwerken. Geef waar mogelijk de voorkeur aan de closurevormen met with... boven handmatige allocatie.
// 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 = 9Korte controle
Bedenk wat een bufferpointer toevoegt ten opzichte van een enkele pointer.
Samenvatting
Bufferpointers omsluiten een aaneengesloten gebied als een begrensde collectie:
UnsafeBufferPointer/UnsafeMutableBufferPointer= basisadres + aantal.- Je krijgt
map,filter,reduceen iteratie metforover onbewerkt geheugen. - Geef bij arrays de voorkeur aan
withUnsafeBufferPointer, zodat Swift geldigheid en levensduur beheert. - Op het opgegeven aantal wordt vertrouwd — leid het af van de echte allocatie.
Leer Swift met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 122
- Lessen
- 409
Veelgestelde vragen
Is de les “Unsafe buffer pointers” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Swift Academy, waaronder “Unsafe buffer pointers”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Swift Academy bevat in totaal 4 lessen.
Wat leer ik in “Unsafe buffer pointers”?
Verwerk aaneengesloten geheugen efficiënt. Je oefent met Swift Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Swift Academy te beginnen?
Ervaring vooraf is niet nodig. Swift Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Unsafe buffer pointers”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Swift Academy?
Ja. Elke les over Swift Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- MemoryLayout en alignment
- UnsafePointer en UnsafeMutablePointer
- Unsafe buffer pointers
- withUnsafeBytes en C-interoperabiliteit