El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Comprendre la Propietat

Següent ►
►

La propietat és un dels conceptes fonamentals en Rust i és clau per comprendre com Rust gestiona la memòria de manera segura i eficient. Aquest concepte pot semblar complex al principi, però és essencial per escriure codi Rust robust i sense errors de memòria.

Conceptes Clau

  1. Propietari (Owner): Cada valor en Rust té un únic propietari.
  2. Moviment (Move): Quan el propietari d'un valor es mou, el valor es transfereix a una nova variable.
  3. Destrucció (Drop): Quan el propietari surt del seu àmbit, el valor es destrueix i la memòria es allibera.

Regles de la Propietat

  1. Cada valor en Rust té un únic propietari.
  2. Quan el propietari surt del seu àmbit, el valor es destrueix.
  3. No es pot tenir més d'un propietari al mateix temps.

Exemples Pràctics

Exemple 1: Propietat Bàsica

fn main() {
    let s1 = String::from("Hola");
    let s2 = s1; // s1 es mou a s2

    // println!("{}", s1); // Això donarà un error perquè s1 ja no és vàlid
    println!("{}", s2); // Això funciona perquè s2 és el nou propietari
}

Explicació:

  • s1 és el propietari inicial de la cadena "Hola".
  • Quan assignem s1 a s2, s1 es mou a s2 i s1 ja no és vàlid.
  • Intentar utilitzar s1 després del moviment donarà un error de compilació.

Exemple 2: Propietat i Funcions

fn main() {
    let s = String::from("Hola");
    prendre_propietat(s); // s es mou a la funció

    // println!("{}", s); // Això donarà un error perquè s ja no és vàlid
}

fn prendre_propietat(s: String) {
    println!("{}", s);
}

Explicació:

  • Quan passem s a la funció prendre_propietat, s es mou a la funció.
  • Després de la crida a la funció, s ja no és vàlid en el context de main.

Exercicis Pràctics

Exercici 1: Moviment de Propietat

fn main() {
    let x = 5;
    let y = x;

    println!("x: {}, y: {}", x, y); // Això funciona perquè els tipus simples com els enters es copien
}

Pregunta: Per què aquest codi funciona sense errors?

Resposta: Els tipus simples com els enters implementen el trait Copy, per la qual cosa es copien en lloc de moure's.

Exercici 2: Propietat amb Tipus Complexos

fn main() {
    let s1 = String::from("Hola");
    let s2 = s1;

    // println!("{}", s1); // Això donarà un error
    println!("{}", s2);
}

Pregunta: Què passa si descomentes la línia println!("{}", s1);?

Resposta: Donarà un error de compilació perquè s1 ja no és vàlid després de moure's a s2.

Errors Comuns i Consells

  • Error Comú: Intentar utilitzar una variable després de moure-la.

    • Consell: Sempre recorda que després de moure una variable, aquesta ja no és vàlida.

  • Error Comú: No comprendre la diferència entre tipus que implementen Copy i els que no.

    • Consell: Familiaritza't amb els tipus que implementen Copy (com els enters, booleans, etc.) i els que no (com String, Vec, etc.).

Conclusió

Comprendre la propietat és essencial per escriure codi Rust segur i eficient. Recorda les regles bàsiques de la propietat i practica amb exemples per consolidar el teu coneixement. En el següent tema, explorarem les referències i el préstec, que et permetran treballar amb dades sense transferir-ne la propietat.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats