Clonar

Cuando se trata de recursos, el comportamiento predeterminado es transferirlos durante las asignaciones o llamadas a funciones. Sin embargo, a veces también necesitamos hacer una copia del recurso.

El rasgo Clone nos ayuda a hacer exactamente esto. Más comúnmente, podemos usar el método .clone() definido por el rasgo Clone.

// Una estructura unidadaria sin recursos
#[derive(Debug, Clone, Copy)]
struct Unidad;

// Una estructura de tupla con recursos que implementa el rasgo `Clone`
#[derive(Clone, Debug)]
struct Par(Box<i32>, Box<i32>);

fn main() {
    // Instancia `Unidad`
    let unidad = Unidad;
    // Copia `Unidad`, no hay recursos para transferir
    let unidad_copiada = unidad;

    // Ambas `Unidad`es se pueden usar de forma independiente
    println!("original: {:?}", unidad);
    println!("copia: {:?}", unidad_copiada);

    // Instancia `Par`
    let par = Par(Box::new(1), Box::new(2));
    println!("original: {:?}", par);

    // Transfire `par` a `par_transferido`, transfire recursos
    let par_transferido = par;
    println!("transferido: {:?}", par_transferido);

    // ¡Error! `par` ha perdido sus recursos
    //println!("original: {:?}", par);
    // TODO ^ Intenta descomentar esta línea

    // Clona `par_transferido` en `par_clonado` (los recursos están incluidos)
    let par_clonado = par_transferido.clone();
    // Suelta el par original usando std::mem::drop
    drop(par_transferido);

    // ¡Error! `par_transferido` ha sido liberado
    //println!("copia: {:?}", par_transferido);
    // TODO ^ Intenta descomentar esta línea

    // ¡El resultado de .clone () aún se puede usar!
    println!("clon: {:?}", par_clonado);
}