Swift Academy · Ders

MemoryLayout ve Hizalama

Türlerin boyutunu, adımını ve hizalamasını inceleyin.

MemoryLayout ve Hizalama, CoddyKit'te ücretsiz bir Swift Academy dersidir. Bu, 4 dersinin 1. 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.

Bellek yerleşimi neden önemlidir

Güvenli olmayan Swift ile çalışırken veya C'ye bağlanırken, değerlerin bellekte nasıl düzenlendiğini bilmeniz gerekir. Swift, ham baytlara hiç dokunmadan bunu incelemeniz için MemoryLayout<T> sağlar.

Üç soruyu yanıtlar: Bir değer ne kadar büyüktür, bir dizideki değerler birbirinden ne kadar uzaktadır ve bir değer hangi adres sınırında başlamalıdır?

// MemoryLayout works on any type
print(MemoryLayout<Int>.size)       // 8 on 64-bit
print(MemoryLayout<Bool>.size)      // 1
print(MemoryLayout<Double>.size)    // 8

size — Gerçek depolama

MemoryLayout<T>.size, değerin anlamlı verilerinin kapladığı bayt sayısıdır. Bir dizide öğeler arasında bulunabilecek sondaki dolguyu içermez.

Tek bir değerin kaç anlamlı bayt tuttuğunu öğrenmek istediğinizde size kullanın.

struct Point {
    var x: Int8   // 1 byte
    var y: Int64  // 8 bytes
}

print(MemoryLayout<Point>.size)   // 16 (not 9 — padding!)

stride — Dizilerde aralık

stride, değerler bitişik bir dizide paketlendiğinde bir öğenin başlangıcı ile sonraki öğenin başlangıcı arasındaki bayt cinsinden uzaklıktır. size değerinin alignment değerine yuvarlanmış hâline eşittir.

Arabellekleri elle ayırırken stride ile çarpın; hiçbir zaman size ile çarpmayın.

print(MemoryLayout<Point>.stride) // 16
print(MemoryLayout<Int8>.stride)  // 1

// Buffer for 10 Points needs:
let bytes = 10 * MemoryLayout<Point>.stride // 160

alignment — Adres sınırları

alignment, bir değerin başlaması gereken bayt sınırıdır. alignment değeri 8 olan bir Int64, 8'e bölünebilen bir adreste başlamalıdır. Derleyici, buna uymak için dolgu ekler.

Bir yapının alignment değeri, üyelerinin en büyük alignment değeridir.

print(MemoryLayout<Int8>.alignment)   // 1
print(MemoryLayout<Int64>.alignment)  // 8
print(MemoryLayout<Point>.alignment)  // 8

size ve stride farkı

Birçok tür için size == stride olsa da dolgu bulunduğunda bu değerler farklılaşır. Bir yapının size değeri 9, stride değeri ise 16 olabilir; çünkü sonraki öğe 8 bayt hizalı olmalıdır.

Pratik kural: tek bir değeri size ile, koleksiyonları ise stride ile değerlendirin.

struct Mixed {
    var flag: Bool   // 1
    var value: Int   // 8
}
print(MemoryLayout<Mixed>.size)   // 16
print(MemoryLayout<Mixed>.stride) // 16

Alan uzaklıkları

Yapılar için her saklanan özelliğin başlangıca göre nerede bulunduğunu, bir anahtar yolu ile MemoryLayout<T>.offset(of:) kullanarak sorabilirsiniz. Bu, verileri bir C yapısıyla eşleşecek şekilde düzenlerken gereklidir.

struct Header {
    var magic: UInt32  // offset 0
    var length: UInt64 // offset 8 (padded)
}

print(MemoryLayout<Header>.offset(of: \Header.magic) ?? -1)  // 0
print(MemoryLayout<Header>.offset(of: \Header.length) ?? -1) // 8

Yer kazanmak için yeniden sıralama

alignment nedeniyle saklanan özelliklerin sırası boyutu etkiler. Daha büyük alanları öne almak veya alanları boyutlarına göre gruplamak bir yapıyı küçültebilir. Boşa giden baytlar büyük dizilerde biriktiği için bu önemlidir.

struct Wasteful { var a: Int8; var b: Int64; var c: Int8 } // size 24
struct Tight    { var b: Int64; var a: Int8; var c: Int8 } // size 16

print(MemoryLayout<Wasteful>.size)
print(MemoryLayout<Tight>.size)

Başvuruların yerleşimi

Bir sınıf örneği yığın üzerinde ayrılır; bu nedenle sınıf başvurusu tutan bir değişken yalnızca bir işaretçidir. Nesne ne kadar büyük olursa olsun MemoryLayout.size değeri işaretçi boyutudur (8 bayt).

Yapılar gibi değer türleri içeriklerini doğrudan saklar; başvuru türleri ise yalnızca işaretçiyi saklar.

class Big { var data = [Int](repeating: 0, count: 1000) }

print(MemoryLayout<Big>.size) // 8 — just the reference

İsteğe bağlı türler ve numaralandırmalar

İsteğe bağlı türler genellikle etiket için bir bayt ekler, ancak Swift başvuru türündeki isteğe bağlı değerleri boş işaretçiyi yeniden kullanacak şekilde optimize eder; bu nedenle String?, String ile aynı boyutta olabilir.

İlişkili değerlere sahip numaralandırmalar, en büyük durumlarını ve bir ayırt ediciyi tutacak şekilde boyutlandırılır.

print(MemoryLayout<Int?>.size)    // 9
print(MemoryLayout<String>.size)  // 16
print(MemoryLayout<String?>.size) // 16 — no extra byte

Bir örnekle of: kullanımı

Her üyenin (size, stride, alignment) örneğe dayalı bir biçimi de vardır: MemoryLayout.size(ofValue:). Türü açıkça yazmanın zor olduğu veya türün çıkarıldığı durumlarda bu kullanışlıdır.

let tuple = (UInt8(1), UInt64(2))
print(MemoryLayout.size(ofValue: tuple))      // 16
print(MemoryLayout.stride(ofValue: tuple))    // 16
print(MemoryLayout.alignment(ofValue: tuple)) // 8

Doğru yerleşimle bellek ayırma

Ham bellek ayırırken hem bayt sayısını hem de alignment değerini iletmeniz gerekir. Bu değerleri MemoryLayout'dan almak, sayıları sabit kodlamak yerine farklı mimarilerde doğruluğu garanti eder.

let count = 4
let capacity = count * MemoryLayout<Int>.stride
let align = MemoryLayout<Int>.alignment

let raw = UnsafeMutableRawPointer.allocate(
    byteCount: capacity, alignment: align)
defer { raw.deallocate() }

Hızlı kontrol

size ve stride arasındaki farkı anlayıp anlamadığınızı sınayın.

Özet

Bellek yerleşiminin üç temel unsurunu öğrendiniz:

size — tek bir değerin anlamlı baytları
stride — dizi öğeleri arasındaki aralık (bellek ayırırken bunu kullanın)
alignment — gerekli başlangıç sınırı

Ayrıca alan konumları için offset(of:) kullanımını, özelliklerin sırasının boyutu nasıl etkilediğini ve başvuruların yalnızca işaretçi boyutunda olduğunu gördünüz. Bu araçlar, ham belleği güvenli şekilde ayırıp yorumlamanızı sağlar.

Sıkça Sorulan Sorular

“MemoryLayout ve Hizalama” dersi ücretsiz mi?

Evet — “MemoryLayout ve Hizalama” 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.

“MemoryLayout ve Hizalama” dersinde ne öğreneceğim?

Türlerin boyutunu, adımını ve hizalamasını inceleyin. 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.

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 1. dersidir.

“MemoryLayout ve Hizalama” 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.

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.

Bu kursun tüm dersleri

MemoryLayout ve Hizalama
UnsafePointer ve UnsafeMutablePointer
Güvenli Olmayan Tampon İşaretçileri
withUnsafeBytes ve C Birlikte Çalışabilirliği

← Swift Academy Sayfasına Dön