Spiegazione di riferimenti e borrowing
Impari a utilizzare riferimenti e borrowing, consentendo a più parti del codice di accedere ai dati senza assumerne l’ownership, in sicurezza.
Spiegazione di riferimenti e borrowing è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 2 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.
Che cosa sono i riferimenti?
In Rust, le variabili sono proprietarie dei propri dati. Ma cosa succede se è necessario permettere ad altre parti del codice di leggere o persino modificare quei dati senza prenderne l'ownership?
È qui che entrano in gioco i riferimenti! Un riferimento è simile a un puntatore a un valore, ma con regole rigide applicate dal compilatore Rust.
È come guardare qualcosa attraverso una finestra invece di possedere direttamente l'oggetto.
Il primo riferimento
Creiamo un riferimento usando l'operatore &. Questo crea un puntatore non proprietario a un valore. Vediamolo in azione:
fn print_length(s: &String) {
println!("The length is: {}", s.len());
}
fn main() {
let message = String::from("Hello, CoddyKit!");
print_length(&message); // Pass a reference
println!("Original message still here: {}", message);
}Capire il borrowing
Quando crea un riferimento a un valore, sta facendo borrowing di quel valore. Il proprietario continua a esserne il titolare, mentre Lei ottiene un accesso temporaneo.
- Prestare senza cedere: può usare i dati presi in prestito.
- Nessun trasferimento dell'ownership: la variabile originale continua a essere proprietaria dei dati e li eliminerà quando uscirà dall'ambito.
- La sicurezza prima di tutto: le regole di borrowing di Rust prevengono errori comuni di programmazione come le race condition sui dati.
Borrowing immutabile: accesso in sola lettura
Per impostazione predefinita, i riferimenti in Rust sono immutabili. Ciò significa che può leggere i dati a cui puntano, ma non può modificarli.
Questa è una funzionalità fondamentale per la sicurezza! Se più parti del codice hanno accesso in sola lettura, non possono interferire accidentalmente con i dati delle altre.
Borrowing immutabile nella pratica
Qui, la funzione calculate_sum riceve un riferimento immutabile a un vettore. Può leggere gli elementi, ma non può aggiungerli o rimuoverli.
fn calculate_sum(numbers: &Vec<i32>) -> i32 {
let mut total = 0;
for num in numbers {
total += num;
}
total
}
fn main() {
let my_numbers = vec![10, 20, 30, 40];
let sum = calculate_sum(&my_numbers); // Immutable borrow
println!("The sum is: {}", sum);
println!("Original vector: {:?}", my_numbers);
}Borrowing mutabile: modificare i dati
A volte è necessario modificare dati presi in prestito. Per farlo, si usa un riferimento mutabile, indicato da &mut.
I riferimenti mutabili sono soggetti a una regola fondamentale: è possibile avere un solo riferimento mutabile a una determinata porzione di dati alla volta. Questo previene le race condition sui dati e garantisce la sicurezza.
Modificare i dati con &mut
La funzione add_suffix riceve un riferimento mutabile a una String. Può modificare direttamente la String originale.
fn add_suffix(text: &mut String) {
text.push_str(" (modified)");
}
fn main() {
let mut my_string = String::from("Original text");
add_suffix(&mut my_string); // Mutable borrow
println!("Modified string: {}", my_string);
}Le regole fondamentali del borrowing
Il compilatore Rust applica queste regole in fase di compilazione per garantire la sicurezza della memoria:
- È possibile avere un riferimento mutabile a una porzione di dati alla volta.
- OPPURE, è possibile avere un numero qualsiasi di riferimenti immutabili alla volta.
- Non è possibile avere un riferimento mutabile mentre sono attivi riferimenti immutabili.
- I riferimenti devono essere sempre validi (non possono avere una durata maggiore dei dati a cui puntano).
Queste regole prevengono le race condition sui dati e garantiscono che i programmi siano sicuri e prevedibili.
Borrowing in conflitto
Questo codice tenta di creare contemporaneamente un riferimento immutabile e uno mutabile a my_value, violando le regole di borrowing di Rust. NON verrà compilato.
Provi a eseguirlo per visualizzare l'errore del compilatore!
fn main() {
let mut my_value = 100;
let r1 = &my_value; // Immutable reference
let r2 = &mut my_value; // Mutable reference (problem here!)
println!("r1: {}", r1);
// println!("r2: {}", r2); // This line would also cause an error if uncommented
}Verifichi la Sua comprensione
Consideri il seguente frammento di codice Rust:
fn process_data(data: &mut Vec<i32>) {
data.push(4);
}
fn main() {
let mut numbers = vec![1, 2, 3];
let first_ref = &numbers[0]; // Line A
process_data(&mut numbers); // Line B
println!("First element: {}", first_ref); // Line C
}Quale linea o quali linee causeranno un errore in fase di compilazione a causa delle regole di borrowing di Rust?
Riepilogo: riferimenti e borrowing
Ottimo lavoro! Ha appreso i fondamenti dei riferimenti e del borrowing in Rust:
- Riferimenti (
&) consentono di accedere ai dati senza acquisirne la proprietà. - Il borrowing consiste nel creare un riferimento, concedendo l'accesso ai dati.
- I riferimenti immutabili (
&) forniscono un accesso in sola lettura. - I riferimenti mutabili (
&mut) forniscono un accesso in lettura e scrittura. - Le rigide regole del borrowing di Rust (uno mutabile OPPURE molti immutabili) prevengono le race condition sui dati e garantiscono la sicurezza della memoria in fase di compilazione.
Questi concetti sono fondamentali per scrivere codice Rust sicuro ed efficiente!
Domande Frequenti
La lezione «Spiegazione di riferimenti e borrowing» è gratuita?
Sì — il testo completo di «Spiegazione di riferimenti e borrowing» è 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 «Spiegazione di riferimenti e borrowing»?
Impari a utilizzare riferimenti e borrowing, consentendo a più parti del codice di accedere ai dati senza assumerne l’ownership, in sicurezza. 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 2 di 3.
Quanto tempo richiede la lezione «Spiegazione di riferimenti e borrowing»?
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
- Comprendere il modello di ownership di Rust
- Spiegazione di riferimenti e borrowing
- Lifetime per riferimenti sicuri