Learn Rust Coding · Lezione

Interagire con Rust unsafe

Comprenda quando e come utilizzare i blocchi `unsafe` per bypassare i controlli di sicurezza di Rust, abilitando FFI e operazioni di basso livello sulla memoria.

Interagire con Rust unsafe è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 3 di 3. 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 Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 3 lezioni in totale.

Rust unsafe: introduzione

Benvenuto in Unsafe Rust! Sebbene Rust sia noto per le sue garanzie di sicurezza della memoria, esistono scenari specifici in cui potrebbe essere necessario aggirare alcuni di questi controlli.

La parola chiave unsafe in Rust consente proprio di farlo. Non è un modo per scrivere codice «cattivo», ma uno strumento per casi d'uso avanzati in cui serve un controllo più diretto sulla memoria o sull'hardware.

I cinque superpoteri di unsafe

Quando usa un blocco unsafe, ottiene accesso a cinque azioni speciali che il compilatore Rust normalmente impedisce:

Dereferenziare puntatori raw: Accedere direttamente agli indirizzi di memoria.
Chiamare funzioni o metodi unsafe: Eseguire funzioni con precondizioni che il compilatore non può verificare.
Implementare trait unsafe: Dichiarare che il proprio tipo rispetta determinati invarianti.
Accedere o modificare variabili statiche mutabili: Condividere stato mutabile a livello globale, con il rischio di race condition.
Accedere ai campi delle union: Leggere da una union, il cui contenuto potrebbe non essere un tipo valido per i dati presenti.

Dereferenziare puntatori raw

I puntatori raw sono indirizzi di memoria privi delle consuete garanzie di sicurezza di Rust. È possibile crearli a partire da riferimenti (&T, &mut T), ma per dereferenziarli è necessario un blocco unsafe.

Questo significa che spetta a Lei, in qualità di programmatore, assicurarsi che il puntatore sia valido e punti a memoria allocata.

fn main() {
  let mut num = 5;
  let r1 = &num as *const i32; // Immutable raw pointer
  let r2 = &mut num as *mut i32; // Mutable raw pointer

  unsafe { // The `unsafe` block starts here
    println!("r1 points to: {}", *r1);
    *r2 = 10; // Modify data through mutable raw pointer
    println!("r2 points to: {}", *r2);
  } // The `unsafe` block ends here

  println!("Num is now: {}", num);
}

Chiamare funzioni unsafe

Alcune funzioni sono contrassegnate come unsafe fn. Ciò significa che la funzione ha precondizioni che il compilatore Rust non può garantire. Ad esempio, potrebbe aspettarsi un indirizzo di memoria valido senza poterlo verificare.

Le chiamate a queste funzioni devono essere racchiuse in un blocco unsafe, a indicare che è Lei, in qualità di chiamante, a garantire il rispetto di tutte le precondizioni.

unsafe fn dangerous_operation() {
  println!("This operation could be dangerous if preconditions aren't met!");
}

fn main() {
  println!("Attempting a dangerous operation...");
  unsafe { // Calling an unsafe function requires `unsafe`
    dangerous_operation();
  }
  println!("Operation completed.");
}

Variabili statiche mutabili

Rust impedisce per impostazione predefinita lo stato globale mutabile, per evitare race condition. Tuttavia, è possibile dichiarare variabili statiche mutabili usando static mut.

Accedere a queste variabili o modificarle è considerato unsafe perché più thread potrebbero tentare di accedervi contemporaneamente, causando un comportamento non definito. La sincronizzazione corretta è responsabilità di chi programma.

static mut COUNTER: i32 = 0; // A mutable static variable

fn add_to_counter(inc: i32) {
  unsafe { // Modifying `static mut` requires `unsafe`
    COUNTER += inc;
  }
}

fn main() {
  add_to_counter(5);
  unsafe { // Reading `static mut` also requires `unsafe`
    println!("COUNTER after first add: {}", COUNTER);
  }

  add_to_counter(10);
  unsafe {
    println!("COUNTER after second add: {}", COUNTER);
  }
}

Implementare trait unsafe

Alcuni trait in Rust sono contrassegnati come unsafe trait. Questo indica che per implementarli è necessario rispettare determinati invarianti che il compilatore non può verificare.

Un esempio comune sono i trait Send e Sync, legati alla sicurezza dei thread. Se implementa manualmente un unsafe trait, deve usare unsafe impl Trait for Type e garantire le relative proprietà di sicurezza.

Per la maggior parte dei principianti, questo caso si presenta meno frequentemente, perché Rust gestisce spesso questi aspetti automaticamente o tramite astrazioni sicure.

Accedere ai campi di una union

Una union è un tipo speciale che può contenere il valore di *una* delle sue varianti in un dato momento, ma tutte le varianti condividono la stessa posizione di memoria. È simile alle union del C.

Accedere a un campo di una union richiede un blocco unsafe perché il compilatore non può sapere quale campo sia attivo in quel momento. Leggere un campo inattivo può causare un comportamento non definito o un'interpretazione errata dei dati.

union Data {
  integer: u32,
  float: f32,
}

fn main() {
  let mut d = Data { integer: 42 }; // Initialize with an integer

  unsafe {
    // Accessing 'integer' is safe here
    println!("Integer value: {}", d.integer);

    // Accessing 'float' is unsafe, as 'integer' was initialized.
    // This would interpret the integer's bits as a float.
    // println!("Float value (unsafe): {}", d.float);
  }

  d.float = 3.14; // Now initialize with a float
  unsafe {
    // Accessing 'float' is safe now
    println!("Float value: {}", d.float);
  }
}

Scenari pratici per unsafe

Sebbene unsafe debba essere usato con parsimonia, è fondamentale per diverse attività di programmazione avanzata:

Foreign Function Interface (FFI): Interagire con codice scritto in altri linguaggi, come le librerie C/C++.
Ottimizzazioni delle prestazioni: In alcuni casi, aggirare i controlli di Rust può produrre piccoli miglioramenti delle prestazioni nelle sezioni critiche (ma misuri prima!).
Programmazione di sistema a basso livello: Scrivere sistemi operativi, driver di dispositivo o sistemi embedded.
Creazione di astrazioni sicure: Implementare strutture dati o API sicure basate su primitive unsafe, come nel caso di Vec.

La Sua responsabilità con unsafe

Quando usa unsafe, si assume la responsabilità di garantire manualmente le garanzie di sicurezza di Rust. Questo significa:

Assicurarsi che la memoria sia valida e correttamente allineata.
Prevenire le race condition quando si gestisce stato mutabile condiviso.
Evitare puntatori pendenti o errori di use-after-free.
Assicurarsi che tutte le precondizioni delle funzioni siano rispettate.

L'uso improprio di unsafe può causare un comportamento non definito, il tipo di bug peggiore e spesso molto difficile da analizzare.

Verifica delle conoscenze su unsafe

Quale delle seguenti azioni richiede un blocco unsafe in Rust?

Riepilogo: Unsafe Rust

Ha imparato a conoscere Unsafe Rust, una funzionalità potente che consente di aggirare alcuni controlli di sicurezza di Rust in fase di compilazione per scenari specifici e avanzati.

Ricordi che unsafe non disattiva completamente il borrow checker, ma trasferisce interamente a Lei, in qualità di programmatore, la responsabilità della sicurezza della memoria e degli invarianti. Lo usi con giudizio e estrema cautela, in genere per FFI, ottimizzazioni a basso livello o per creare astrazioni sicure.

Domande Frequenti

La lezione «Interagire con Rust unsafe» è gratuita?

Sì — il testo completo di «Interagire con Rust unsafe» è 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 Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 3 lezioni in totale.

Cosa imparerò in «Interagire con Rust unsafe»?

Comprenda quando e come utilizzare i blocchi `unsafe` per bypassare i controlli di sicurezza di Rust, abilitando FFI e operazioni di basso livello sulla memoria. Eserciti Learn Rust Coding 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 Learn Rust Coding?

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

Quanto tempo richiede la lezione «Interagire con Rust unsafe»?

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 Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding 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

← Torna a Learn Rust Coding