En aquest tema, explorarem dos conceptes fonamentals en Rust: les referències i el préstec. Aquests conceptes són crucials per comprendre com Rust gestiona la memòria de manera segura i eficient.
Què són les Referències?
Les referències permeten accedir a una variable sense prendre'n la propietat. Això és útil quan volem llegir o modificar una variable sense transferir-ne la propietat.
Creació de Referències
Per crear una referència a una variable, utilitzem el símbol &. Aquí teniu un exemple:
fn main() {
let x = 5;
let y = &x; // y és una referència a x
println!("El valor de x és: {}", x);
println!("El valor de y és: {}", y);
}Referències Immutables
Les referències per defecte són immutables, el que significa que no podem modificar la variable a través de la referència.
fn main() {
let x = 5;
let y = &x;
// *y = 6; // Això donarà un error perquè y és una referència immutable
}Referències Mutables
Si volem modificar la variable a través de la referència, hem de fer servir una referència mutable. Per crear una referència mutable, utilitzem &mut.
fn main() {
let mut x = 5;
let y = &mut x; // y és una referència mutable a x
*y = 6; // Modifiquem el valor de x a través de y
println!("El valor de x és: {}", x);
}Préstec
El préstec és el mecanisme que Rust utilitza per gestionar les referències. Hi ha dues regles principals per al préstec:
- Només pot haver-hi una referència mutable a una variable en un moment donat.
- Poden haver-hi múltiples referències immutables a una variable, però no poden coexistir amb una referència mutable.
Exemple de Préstec
fn main() {
let mut x = 5;
let y = &x; // Referència immutable a x
let z = &x; // Una altra referència immutable a x
println!("El valor de y és: {}", y);
println!("El valor de z és: {}", z);
// let w = &mut x; // Això donarà un error perquè ja hi ha referències immutables a x
}Exemple de Préstec Mutu
fn main() {
let mut x = 5;
{
let y = &mut x; // Referència mutable a x
*y += 1; // Modifiquem el valor de x a través de y
} // y surt del seu àmbit aquí, així que podem crear una nova referència mutable
let z = &mut x; // Una nova referència mutable a x
*z += 1;
println!("El valor de x és: {}", x);
}Exercicis Pràctics
Exercici 1
Crea una funció que prengui una referència immutable a un enter i imprimeixi el seu valor.
fn imprimir_valor(x: &i32) {
println!("El valor és: {}", x);
}
fn main() {
let x = 10;
imprimir_valor(&x);
}Exercici 2
Crea una funció que prengui una referència mutable a un enter i incrementi el seu valor en 1.
fn incrementar(x: &mut i32) {
*x += 1;
}
fn main() {
let mut x = 10;
incrementar(&mut x);
println!("El valor incrementat és: {}", x);
}Errors Comuns i Consells
- Referències Dangling: Assegura't que les referències no apunten a dades que ja no existeixen.
- Conflictes de Préstec: Recorda les regles de préstec per evitar errors de compilació.
- Àmbit de les Referències: Les referències han de viure dins del seu àmbit. Quan una referència surt del seu àmbit, ja no és vàlida.
Conclusió
Les referències i el préstec són conceptes fonamentals en Rust que permeten gestionar la memòria de manera segura i eficient. Comprendre com funcionen les referències immutables i mutables, així com les regles de préstec, és essencial per escriure codi Rust robust i lliure d'errors. En el proper tema, explorarem els slices, una altra eina poderosa per treballar amb dades en Rust.