Swift Academy · Ders

Güvenli Olmayan Tampon İşaretçileri

Q: “Güvenli Olmayan Tampon İşaretçileri” dersi ücretsiz mi?

Evet — “Güvenli Olmayan Tampon İşaretçileri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Swift Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Swift Academy kursu toplamda 4 dersten oluşur.

Q: “Güvenli Olmayan Tampon İşaretçileri” dersinde ne öğreneceğim?

Bitişik belleği verimli biçimde işleyin. Swift Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Q: Swift Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Swift Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

Q: “Güvenli Olmayan Tampon İşaretçileri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Q: Bu Swift Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Swift Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bitişik belleği verimli biçimde işleyin.

Güvenli Olmayan Tampon İşaretçileri, CoddyKit'te ücretsiz bir Swift Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Swift Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Swift Academy kursu toplamda 4 dersten oluşur.

Arabellek İşaretçisi Nedir

Tek bir türü belirlenmiş işaretçi, her seferinde bir elemana erişir. UnsafeBufferPointer<T>, başlangıç işaretçisi ile bir sayıyı bir araya getirerek Collection protokolüne uyan bitişik bir bellek bloğunun sınırlandırılmış görünümünü sunar.

Bu, ham bellek üzerinde tanıdık koleksiyon API'lerinin tümünü kullanarak üzerinde dolaşabileceğiniz, alt indisleme yapabileceğiniz, eşleyebileceğiniz ve reduce işlemi uygulayabileceğiniz anlamına gelir.

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

Salt Okunur ve Değiştirilebilir Arabellekler

Tekil işaretçiler gibi arabelleklerin de iki türü vardır: salt okunur dolaşma için UnsafeBufferPointer<T> ve elemanlara değer atamanız gerektiğinde UnsafeMutableBufferPointer<T>.

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

Koleksiyon Gibi Üzerinde Dolaşma

Bir arabellek işaretçisi Collection olduğu için for döngüsü her elemanın üzerinden sırayla geçer. El ile dizin aritmetiği yapmanız gerekmez ve döngünün kendisinde sınır aşımı riski yoktur; ancak verdiğiniz sınırlar hâlâ sizin sorumluluğunuzdadır.

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

Koleksiyon Algoritmalarını Ücretsiz Kullanma

map, filter, reduce, enumerated ve indices işlemlerinin tümü arabellek işaretçileriyle çalışır. Böylece ayırma işlemi yapmadan yüksek düzeyli kodla ham belleği işleyebilirsiniz.

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)

Değiştirilebilir Arabellek Ayırma

UnsafeMutableBufferPointer<T>.allocate(capacity:), bellek bloğunu ayırır ve tek adımda bir arabellek döndürür. Okumadan önce yine de initialize çağırmanız, işiniz bittiğinde de deallocate çağırmanız gerekir.

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

Sınırlar Uçta Denetlenmez

0..<count içindeki alt indisleme işlemleri güvenlidir. Ancak arabellek, sağladığınız count değerinin doğru olup olmadığını bilemez. Gerçek ayırmadan daha büyük bir count değeriyle arabellek oluşturursanız okumalar bloğun sonunu aşarak tanımsız belleğe taşar.

count değerini her zaman oluşturduğunuz ayırma işleminden türetin.

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)

Boş Arabellekler

count: 0 değerine sahip bir arabellek geçerlidir ve nil bir temel adrese sahip olabilir. baseAddress değerini zorla açmak yerine her zaman isEmpty değerini denetleyin veya döngünün hiç çalışmamasına güvenin.

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

Dizilerde withUnsafeBufferPointer

Arabellek elde etmenin en güvenli yolu, mevcut bir Array üzerinden withUnsafeBufferPointer kullanmaktır. Swift, depolama alanının bitişik olmasını ve kapanışın süresi boyunca geçerli kalmasını garanti eder; böylece el ile ayırma yapmanız gerekmez.

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

Dizi Depolama Alanını Değiştirme

withUnsafeMutableBufferPointer, bir dizinin depolama alanına doğrudan yazmanızı sağlar. Bu yöntem, ARC ve sınır denetimlerinin ek yük oluşturacağı, performans açısından kritik yerinde dönüşümlerde zaman zaman kullanılır.

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

C API'leri için baseAddress

İşaretçi ve uzunluk bekleyen bir C işlevini çağırırken buffer.baseAddress ile buffer.count değerlerini geçirin. Temel adres yalnızca boş arabelleklerde nil olur; bu durumu ele alın.

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

Arabellek İşaretçileri Ne Zaman Kullanılmalı

Belleğin bir bölgesine bitişik, tür güvenli ve koleksiyon tarzı erişmeniz gerektiğinde arabellek işaretçilerini kullanın: C dizilerini bağlamak, ikili biçimleri ayrıştırmak veya yoğun döngülerde ek yükü azaltmak için. Mümkün olduğunda el ile ayırma yerine with... kapanış biçimlerini tercih edin.

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

Kısa Kontrol

Bir arabellek işaretçisinin tek bir işaretçiye kıyasla ne eklediğini hatırlayın.

Özet

Arabellek işaretçileri, bitişik bir bölgeyi sınırlandırılmış bir koleksiyon olarak sarar:

UnsafeBufferPointer / UnsafeMutableBufferPointer = temel adres + count.
Ham bellek üzerinde map, filter, reduce ve for döngüsüyle dolaşma işlemlerini kullanabilirsiniz.
Geçerliliği ve ömrü Swift'in yönetmesi için dizilerde withUnsafeBufferPointer kullanımını tercih edin.
Sağlanan count değerine güvenilir; bu değeri gerçek ayırma işleminden türetin.

Sıkça Sorulan Sorular