Swift Academy · Lektion

withUnsafeBytes und C-Interop

Binden Sie C-APIs an, die rohe Bytes erwarten.

withUnsafeBytes und C-Interop ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Von typisierten Werten zu rohen Bytes

Manchmal müssen Sie einen Wert nicht als Int oder als struct, sondern als Folge von rohen Bytes betrachten – etwa um ihn zu hashen, in eine Datei zu schreiben oder an eine C-API zu übergeben. withUnsafeBytes liefert genau das: eine temporäre Sicht auf den Speicher eines Werts als UInt8.

var value: UInt32 = 0x01020304
withUnsafeBytes(of: &value) { rawBuffer in
    print(rawBuffer.count) // 4 bytes
}

Der UnsafeRawBufferPointer

Die Closure erhält einen UnsafeRawBufferPointer – einen Buffer aus Bytes ohne Elementtyp. Sie indizieren ihn, um einzelne UInt8-Werte zu lesen. Er ist schreibgeschützt; die veränderbare Variante ist withUnsafeMutableBytes.

var value: UInt32 = 0x01020304
withUnsafeBytes(of: &value) { bytes in
    for b in bytes { print(String(format: "%02x", b)) }
}
// Order depends on endianness

Die Byte-Reihenfolge ist wichtig

Die beobachtete Byte-Reihenfolge hängt von der Endianness der Plattform ab. Auf Little-Endian-Systemen (Apple silicon, Intel) steht das niederwertigste Byte zuerst. Beim Serialisieren für ein Protokoll konvertieren Sie explizit mit bigEndian oder littleEndian.

let host: UInt32 = 0x01020304
let networkOrder = host.bigEndian
var be = networkOrder
withUnsafeBytes(of: &be) { bytes in
    // Always 01 02 03 04 regardless of platform
    print(Array(bytes))
}

Bytes einer Struct

withUnsafeBytes(of:) funktioniert mit jedem Wert, auch mit Structs. Die Pufferlänge entspricht MemoryLayout<T>.size, und enthaltene Padding-Bytes sind eingeschlossen, ihr Inhalt ist jedoch nicht spezifiziert.

struct RGB { var r: UInt8; var g: UInt8; var b: UInt8 }
var color = RGB(r: 255, g: 128, b: 0)
withUnsafeBytes(of: &color) { bytes in
    print(bytes[0], bytes[1], bytes[2]) // 255 128 0
}

Einen Wert aus Bytes laden

Um rohe Bytes als typisierten Wert neu zu interpretieren, verwenden Sie load(fromByteOffset:as:) auf einem Raw-Buffer. Der Offset muss das Alignment des Typs berücksichtigen, und die Bytes müssen tatsächlich einen gültigen Wert dieses Typs darstellen.

let raw: [UInt8] = [0x04, 0x03, 0x02, 0x01]
let n = raw.withUnsafeBytes { ptr in
    ptr.load(fromByteOffset: 0, as: UInt32.self)
}
print(String(format: "0x%08x", n))

loadUnaligned für gepackte Daten

Binärformate packen Felder häufig ohne Alignment-Padding. load an einem nicht ausgerichteten Offset aufzurufen ist undefiniertes Verhalten; verwenden Sie stattdessen loadUnaligned(fromByteOffset:as:), um sicher von jedem Offset zu lesen.

let packet: [UInt8] = [0xFF, 0x04, 0x03, 0x02, 0x01]
let field = packet.withUnsafeBytes { ptr in
    ptr.loadUnaligned(fromByteOffset: 1, as: UInt32.self)
}
print(field)

Data an C anbinden

Viele C-Funktionen akzeptieren einen const void * sowie eine Länge. Data und Arrays stellen withUnsafeBytes bereit, sodass Sie baseAddress und count direkt und ohne Kopieren übergeben können.

import Foundation
let data = Data([0x68, 0x69]) // "hi"
data.withUnsafeBytes { (raw: UnsafeRawBufferPointer) in
    if let base = raw.baseAddress {
        // c_consume(base, raw.count)
        print("ptr", base, "len", raw.count)
    }
}

Einen C-Zeiger empfangen

Wenn ein C-Callback Ihnen einen const void * und eine Länge übergibt, wickeln Sie ihn in einen UnsafeRawBufferPointer, um sicher zu iterieren. Swift importiert den C-Zeiger als UnsafeRawPointer?.

func handleC(_ ptr: UnsafeRawPointer, _ len: Int) {
    let buffer = UnsafeRawBufferPointer(start: ptr, count: len)
    let checksum = buffer.reduce(0) { $0 &+ Int($1) }
    print("checksum:", checksum)
}

bindMemory und Neuinterpretation

Um einen Raw-Bereich als typisierte Elemente zu behandeln, teilt bindMemory(to:capacity:) dem Compiler mit, wie er ihn interpretieren soll. Ein Missbrauch davon – das Binden desselben Speichers an zwei inkompatible Typen – verletzt die strikten Aliasing-Regeln von Swift und ist undefiniert.

let raw = UnsafeMutableRawPointer.allocate(
    byteCount: 8, alignment: 8)
defer { raw.deallocate() }
let typed = raw.bindMemory(to: Int.self, capacity: 1)
typed.pointee = 1234
print(typed.pointee)

assumingMemoryBound vs bindMemory

bindMemory ändert die Interpretation des Speichers dauerhaft; assumingMemoryBound(to:) behauptet, dass er bereits an diesen Typ gebunden ist, ohne etwas zu ändern. Verwenden Sie Letzteres nur, wenn Sie die bestehende Bindung sicher kennen, etwa bei Speicher, von dem Sie wissen, dass er den angegebenen Typ enthält.

func sumInts(_ raw: UnsafeRawPointer, _ count: Int) -> Int {
    let p = raw.assumingMemoryBound(to: Int.self)
    var total = 0
    for i in 0..<count { total += p[i] }
    return total
}

Sicherheits-Checkliste

Bei Raw-Bytes und C-Interoperabilität verbergen sich die meisten Abstürze. Denken Sie an Folgendes:

Lassen Sie den Zeiger der Closure niemals entweichen.
Halten Sie das Alignment ein oder verwenden Sie die Unaligned-Varianten.
Behandeln Sie endianness beim Serialisieren explizit.
Binden Sie Speicher nicht an inkompatible Typen um.
Berücksichtigen Sie bei leeren Buffern eine nil-baseAddress.

// Convert any value to a hex string safely
import Foundation
func hex<T>(_ v: T) -> String {
    var value = v
    return withUnsafeBytes(of: &value) { bytes in
        bytes.map { String(format: "%02x", $0) }.joined()
    }
}

Schnelltest

Testen Sie Ihr Verständnis für das Lesen gepackter Binärdaten.

Zusammenfassung

Sie haben gelernt, Swift-Werte und C über rohe Bytes zu verbinden:

withUnsafeBytes(of:) stellt jeden Wert als UInt8 dar.
load / loadUnaligned interpretieren Bytes unter Berücksichtigung des Alignments als typisierte Werte.
Data und Arrays stellen withUnsafeBytes bereit, um Zeiger und Länge an C zu übergeben.
bindMemory und assumingMemoryBound steuern, wie Raw-Speicher typisiert wird.
Endianness, Alignment und das Entweichen von Zeigern sind die wichtigsten Gefahren.

Häufig gestellte Fragen

Ist die Lektion „withUnsafeBytes und C-Interop“ kostenlos?

Ja — der vollständige Text von „withUnsafeBytes und C-Interop“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „withUnsafeBytes und C-Interop“?

Binden Sie C-APIs an, die rohe Bytes erwarten. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „withUnsafeBytes und C-Interop“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Swift Academy