Swift Academy · Pelajaran

MemoryLayout dan Alignment

Periksa ukuran, stride, dan alignment tipe.

MemoryLayout dan Alignment adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Mengapa Tata Letak Memori Penting

Saat Anda bekerja dengan Swift unsafe atau menjembatani ke C, Anda perlu mengetahui bagaimana nilai disusun dalam memori. Swift menyediakan MemoryLayout<T> untuk memeriksanya tanpa menyentuh bytes secara langsung.

Ini menjawab tiga pertanyaan: seberapa besar sebuah nilai, seberapa jauh jarak antar nilai dalam array, dan pada batas alamat mana sebuah nilai harus dimulai.

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

size — Penyimpanan Aktual

MemoryLayout<T>.size adalah jumlah bytes yang ditempati data penting milik nilai tersebut. Nilai ini tidak mencakup padding di akhir yang mungkin berada di antara elemen dalam array.

Gunakan size saat Anda ingin mengetahui jumlah bytes bermakna yang disimpan oleh satu nilai.

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

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

stride — Jarak dalam Array

stride adalah jarak dalam bytes antara awal satu elemen dan elemen berikutnya saat nilai dikemas dalam array yang berkesinambungan. Nilainya sama dengan size yang dibulatkan ke atas sesuai alignment.

Saat Anda mengalokasikan buffer secara manual, kalikan dengan stride, jangan pernah dengan size.

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

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

alignment — Batas Alamat

alignment adalah batas bytes tempat sebuah nilai harus dimulai. Int64 dengan alignment 8 harus dimulai pada alamat yang habis dibagi 8. Kompilator menyisipkan padding untuk mematuhinya.

alignment sebuah struktur adalah alignment terbesar di antara anggotanya.

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

Perbedaan size dan stride

Pada banyak jenis, size == stride, tetapi keduanya berbeda jika terdapat padding. Sebuah struktur mungkin memiliki size 9, tetapi stride 16 karena elemen berikutnya harus selaras pada batas 8 bytes.

Aturan praktis: gunakan size untuk memahami satu nilai, dan gunakan stride untuk memahami kumpulan nilai.

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

Offset Bidang

Untuk struktur, Anda dapat menanyakan posisi setiap properti tersimpan relatif terhadap awal menggunakan MemoryLayout<T>.offset(of:) dengan jalur kunci. Ini penting saat menyusun data agar sesuai dengan struktur C.

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

Mengatur Ulang untuk Menghemat Ruang

Karena alignment, urutan properti tersimpan memengaruhi ukuran. Menempatkan bidang yang lebih besar di awal atau mengelompokkannya berdasarkan ukuran dapat memperkecil struktur. Hal ini penting untuk array besar karena bytes yang terbuang akan terus bertambah.

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)

Tata Letak Referensi

Instans kelas dialokasikan di heap, sehingga variabel yang menyimpan referensi kelas hanyalah sebuah penunjuk. MemoryLayout.size-nya adalah ukuran penunjuk (8 bytes), terlepas dari ukuran objeknya.

Jenis nilai seperti struktur menyimpan isinya secara langsung; jenis referensi hanya menyimpan penunjuk.

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

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

Optional dan Enum

Optional biasanya menambahkan satu byte untuk tag, tetapi Swift mengoptimalkan optional referensi dengan menggunakan kembali penunjuk null, sehingga String? dapat berukuran sama dengan String.

Enum dengan nilai terkait berukuran cukup untuk menampung kasus terbesarnya ditambah diskriminator.

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

Menggunakan of: dengan Instans

Setiap anggota (size, stride, alignment) juga memiliki bentuk berbasis instans: MemoryLayout.size(ofValue:). Ini berguna saat jenisnya sulit dituliskan secara eksplisit atau ditentukan melalui inferensi.

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

Mengalokasikan dengan Tata Letak yang Benar

Saat Anda mengalokasikan memori raw, Anda harus memberikan jumlah bytes dan alignment. Mendapatkan keduanya dari MemoryLayout menjamin ketepatan pada berbagai arsitektur, bukan dengan menetapkan angka secara langsung.

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

Pemeriksaan Singkat

Uji pemahaman Anda tentang perbedaan size dan stride.

Ringkasan

Anda telah mempelajari tiga pilar tata letak memori:

size — bytes bermakna dari satu nilai
stride — jarak antar elemen array (gunakan ini untuk alokasi)
alignment — batas awal yang diperlukan

Anda juga telah melihat offset(of:) untuk posisi bidang, bagaimana urutan properti memengaruhi ukuran, dan bahwa referensi hanya berukuran sebesar penunjuk. Alat-alat ini memungkinkan Anda mengalokasikan dan menafsirkan memori raw dengan aman.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “MemoryLayout dan Alignment” gratis?

Ya — teks lengkap “MemoryLayout dan Alignment” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “MemoryLayout dan Alignment”?

Periksa ukuran, stride, dan alignment tipe. Kamu berlatih Swift Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “MemoryLayout dan Alignment” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Swift Academy