Swift Academy · Lezione

withUnsafeBytes e interoperabilità con C

Colleghi le API C che richiedono byte grezzi.

Lezione 4 di 413 passaggi

withUnsafeBytes e interoperabilità con C è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Dai tipi ai byte grezzi

A volte è necessario osservare un valore non come Int o struct, ma come una sequenza di byte grezzi, ad esempio per calcolarne l'hash, scriverlo in un file o passarlo a un'API C. withUnsafeBytes offre esattamente questo: una vista temporanea dello storage di un valore come UInt8.

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

UnsafeRawBufferPointer

La closure riceve un UnsafeRawBufferPointer, ovvero un buffer di byte privo di tipo per gli elementi. È possibile indicizzarlo per leggere singoli valori UInt8. È di sola lettura; la variante mutabile è withUnsafeMutableBytes.

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

L'endianness è importante

L'ordine dei byte osservato dipende dall'endianness della piattaforma. Sulle macchine little-endian, come Apple silicon e Intel, il byte meno significativo viene per primo. Quando serializza dati per un protocollo, converta esplicitamente usando bigEndian o 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))
}

I byte di una struct

withUnsafeBytes(of:) funziona con qualsiasi valore, incluse le struct. La lunghezza del buffer è uguale a MemoryLayout<T>.size e include anche eventuali byte di padding, il cui contenuto non è specificato.

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
}

Caricare un valore dai byte

Per reinterpretare i byte grezzi come un valore tipizzato, usi load(fromByteOffset:as:) su un buffer grezzo. L'offset deve rispettare l'allineamento del tipo e i byte devono rappresentare effettivamente un valore valido di quel tipo.

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 per i dati impacchettati

I formati binari spesso impacchettano i campi senza padding per l'allineamento. Chiamare load a un offset non allineato produce un comportamento non definito; usi invece loadUnaligned(fromByteOffset:as:) per leggere in sicurezza da qualsiasi offset.

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

Collegare Swift Data al C

Molte funzioni C accettano un const void * più una lunghezza. Data e gli array espongono withUnsafeBytes, consentendo di passare direttamente baseAddress e count senza copiare i dati.

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

Ricevere un puntatore C

Quando una callback C fornisce un const void * e una lunghezza, lo racchiuda in un UnsafeRawBufferPointer per iterare in sicurezza. Swift importerà il puntatore C come 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 e reinterpretazione

Per trattare una regione grezza come un insieme di elementi tipizzati, bindMemory(to:capacity:) comunica al compilatore come interpretarla. Un uso scorretto, ovvero associare la stessa memoria a due tipi incompatibili, viola le rigide regole di aliasing di Swift e produce un comportamento non definito.

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 rispetto a bindMemory

bindMemory cambia permanentemente il modo in cui la memoria viene interpretata; assumingMemoryBound(to:) afferma invece che essa è già associata a quel tipo, senza apportare modifiche. Usi quest'ultima solo quando è certo dell'associazione esistente, ad esempio per una memoria che sa contenere il tipo indicato.

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
}

Elenco di controllo della sicurezza

È nell'accesso ai byte grezzi e nell'interoperabilità con C che si nascondono la maggior parte dei crash. Ricordi:

Non lasci mai che il puntatore della closure sfugga al suo ambito.
Rispetti l'allineamento oppure usi le varianti Unaligned.
Gestisca esplicitamente l'endianness durante la serializzazione.
Non associ nuovamente la memoria a tipi in conflitto.
Gestisca il caso di baseAddress nil per i buffer vuoti.

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

Verifica rapida

Verifichi la Sua comprensione della lettura di dati binari impacchettati.

Rispondi nella lezione interattiva

Riepilogo

Ha imparato a collegare i valori Swift e il C tramite i byte grezzi:

withUnsafeBytes(of:) visualizza qualsiasi valore come UInt8.
load / loadUnaligned reinterpretano i byte come valori tipizzati rispettando l'allineamento.
Data e gli array espongono withUnsafeBytes per passare a C un puntatore più una lunghezza.
bindMemory e assumingMemoryBound controllano il modo in cui viene tipizzata la memoria grezza.
Endianness, allineamento e fuoriuscita del puntatore sono i principali rischi.

Gratis per iniziare

Impara Swift con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 122
Lezioni: 409

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «withUnsafeBytes e interoperabilità con C» è gratuita?

Sì — il testo completo di «withUnsafeBytes e interoperabilità con C» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «withUnsafeBytes e interoperabilità con C»?

Colleghi le API C che richiedono byte grezzi. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «withUnsafeBytes e interoperabilità con C»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

MemoryLayout e allineamento
UnsafePointer e UnsafeMutablePointer
Puntatori buffer non sicuri
withUnsafeBytes e interoperabilità con C

← Torna a Swift Academy