PricingLoginStart free
Swift Academy · leksjon

Usikre bufferpekere

Behandle sammenhengende minne effektivt.

Leksjon 3 av 413 trinn

Usikre bufferpekere er en gratis leksjon i Swift Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Swift Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Hva en bufferpeker er

En enkelt typet peker adresserer ett element om gangen. En UnsafeBufferPointer<T> omslutter en startpeker pluss et antall og gir en avgrenset visning over en sammenhengende minneblokk som oppfyller Collection.

Det betyr at det er mulig å iterere, bruke subscript, map og reduce – alle de kjente samlings-API-ene over råminne.

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

Skrivebeskyttede kontra mutable buffere

I likhet med enkeltpekere finnes buffere i to varianter: UnsafeBufferPointer<T> for skrivebeskyttet iterasjon og UnsafeMutableBufferPointer<T> når det også er nødvendig å tilordne elementer.

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

Iterering som i en samling

Fordi en bufferpeker er en Collection, går en for-løkke gjennom hvert element i rekkefølge. Ingen manuell indeksaritmetikk og ingen risiko for avgrensningsfeil i selve løkken – selv om grensene som ble oppgitt fortsatt er utviklerens ansvar.

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

Samlingsalgoritmer uten ekstra arbeid

map, filter, reduce, enumerated og indices fungerer alle på bufferpekere. Dermed kan råminne behandles med høynivåkode, samtidig som allokering unngås.

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)

Allokering av en mutable buffer

UnsafeMutableBufferPointer<T>.allocate(capacity:) reserverer minneblokken og returnerer en buffer i ett trinn. Det er fortsatt nødvendig å initialize før lesing og deallocate når arbeidet er ferdig.

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

Grenser kontrolleres ikke ved minnegrensen

Indeksering innenfor 0..<count er greit. Men bufferen kan ikke vite om antallet som ble oppgitt var riktig. Hvis det bygges en buffer med et antall som er større enn den faktiske allokeringen, går lesingene forbi slutten og inn i udefinert minne.

Avled alltid antallet fra den samme allokeringen som ble opprettet.

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)

Tomme buffere

En buffer med count: 0 er gyldig og kan ha en nil-baseadresse. Kontroller alltid isEmpty, eller stol på at løkken ganske enkelt ikke kjøres, i stedet for å tvangsutpakke baseAddress.

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

withUnsafeBufferPointer på arrayer

Den sikreste måten å hente en buffer på er fra en eksisterende Array via withUnsafeBufferPointer. Swift garanterer at lagringen er sammenhengende og gyldig så lenge closure-en varer, slik at man unngår manuell allokering helt.

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

Endring av Array-lagring

withUnsafeMutableBufferPointer gjør det mulig å skrive direkte til lagringen i en array. Dette brukes av og til til ytelseskritiske transformasjoner på stedet, der ARC og avgrensningskontroller ellers ville medført ekstra overhead.

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 for C-API-er

Ved kall av en C-funksjon som forventer en peker pluss en lengde, sendes buffer.baseAddress og buffer.count. Baseadressen er nil bare for tomme buffere, så dette tilfellet må håndteres.

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)
    }
}

Når bufferpekere bør brukes

Bruk bufferpekere når det er behov for sammenhengende, typesikker tilgang til et minneområde i samlingsstil: for å bygge bro til C-arrayer, tolke binærformater eller redusere overhead i varme løkker. Foretrekk with...-closure-varianter fremfor manuell allokering når det er mulig.

// 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

Hurtigsjekk

Husk hva en bufferpeker tilfører sammenlignet med en enkelt peker.

Besvar den i den interaktive leksjonen

Oppsummering

Bufferpekere omslutter et sammenhengende område som en avgrenset samling:

  • UnsafeBufferPointer / UnsafeMutableBufferPointer = baseadresse + antall.
  • Det er mulig å bruke map, filter, reduce og for-iterasjon over råminne.
  • Foretrekk withUnsafeBufferPointer på arrayer, slik at Swift håndterer gyldighet og levetid.
  • Det oppgitte antallet stoles på – avled det fra den faktiske allokeringen.
Gratis å komme i gang

Lær deg Swift med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
122
Leksjoner
409
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Usikre bufferpekere» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Swift Academy, inkludert «Usikre bufferpekere», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Usikre bufferpekere»?

Behandle sammenhengende minne effektivt. Du øver på Swift Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Swift Academy?

Ingen tidligere erfaring er nødvendig. Swift Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Usikre bufferpekere»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Swift Academy-leksjonen?

Ja. Alle Swift Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. MemoryLayout og justering
  2. UnsafePointer og UnsafeMutablePointer
  3. Usikre bufferpekere
  4. withUnsafeBytes og C-interoperabilitet
← Tilbake til Swift Academy