Desestructuración y Desreferenciación en Rust

Introducción

En este laboratorio, exploraremos los conceptos de desestructuración y desreferenciación en Rust, destacando las diferencias en su uso en comparación con lenguajes como C/C++. La desestructuración implica el uso de &, ref y ref mut para asignar y coincidir con referencias, mientras que la desreferenciación se realiza usando * para acceder al valor apuntado por una referencia.

Nota: Si el laboratorio no especifica un nombre de archivo, puede usar cualquier nombre de archivo que desee. Por ejemplo, puede usar main.rs, compilar y ejecutarlo con rustc main.rs &&./main.

pointers/ref

Para los punteros, es necesario distinguir entre la desestructuración y la desreferenciación, ya que son conceptos diferentes que se usan de manera distinta a los lenguajes como C/C++.

• La desreferenciación utiliza *
• La desestructuración utiliza &, ref y ref mut

fn main() {
    // Asigna una referencia de tipo `i32`. El `&` significa que
    // se está asignando una referencia.
    let reference = &4;

    match reference {
        // Si `reference` se coincide con el patrón `&val`, se produce
        // una comparación como:
        // `&i32`
        // `&val`
        // ^ Vemos que si se eliminan los `&` coincidentes, entonces el `i32`
        // debe ser asignado a `val`.
        &val => println!("Got a value via destructuring: {:?}", val),
    }

    // Para evitar el `&`, se desreferencia antes de coincidir.
    match *reference {
        val => println!("Got a value via dereferencing: {:?}", val),
    }

    // ¿Qué pasa si no se comienza con una referencia? `reference` era un `&`
    // porque el lado derecho ya era una referencia. Esto no
    // es una referencia porque el lado derecho no lo es.
    let _not_a_reference = 3;

    // Rust proporciona `ref` precisamente para este propósito. Modifica la
    // asignación para que se cree una referencia para el elemento; esta
    // referencia se asigna.
    let ref _is_a_reference = 3;

    // En consecuencia, al definir 2 valores sin referencias, se pueden
    // recuperar referencias a través de `ref` y `ref mut`.
    let value = 5;
    let mut mut_value = 6;

    // Utiliza la palabra clave `ref` para crear una referencia.
    match value {
        ref r => println!("Got a reference to a value: {:?}", r),
    }

    // Utiliza `ref mut` de manera similar.
    match mut_value {
        ref mut m => {
            // Obtuvimos una referencia. Tenemos que desreferenciarla antes de poder
            // agregarle nada.
            *m += 10;
            println!("We added 10. `mut_value`: {:?}", m);
        },
    }
}

Resumen

¡Felicidades! Has completado el laboratorio de Pointers/Ref. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.