¿Cuál es la diferencia entre Copiar y Clonar?

Este problema parece implicar que es solo un detalle de implementación ( memcpyvs ???), pero no puedo encontrar ninguna descripción explícita de las diferencias.

Cloneestá diseñado para duplicaciones arbitrarias: una Cloneimplementación para un tipo Tpuede realizar operaciones arbitrariamente complicadas necesarias para crear un nuevo T. Es un rasgo normal (aparte de estar en el preludio), por lo que requiere que se use como un rasgo normal, con llamadas a métodos, etc.

El Copyrasgo representa valores que se pueden duplicar de forma segura a través de memcpy: cosas como reasignaciones y pasar un valor por argumento a una función son siempre memcpys, por lo que para los Copytipos, el compilador comprende que no necesita considerarlos como un movimiento .

La principal diferencia es que la clonación es explícita. La notación implícita significa mover para un no Copytipo.

// u8 implements Copy
let x: u8 = 123;
let y = x;
// x can still be used
println!("x={}, y={}", x, y);

// Vec<u8> implements Clone, but not Copy
let v: Vec<u8> = vec![1, 2, 3];
let w = v.clone();
//let w = v // This would *move* the value, rendering v unusable.

Por cierto, todos los Copytipos también deben serlo Clone. Sin embargo, ¡no están obligados a hacer lo mismo! Para sus propios tipos, .clone()puede ser un método arbitrario de su elección, mientras que la copia implícita siempre activará a memcpy, no la clone(&self)implementación.

Como ya se cubrió en otras respuestas:

• Copy es implícito, económico y no se puede volver a implementar (memcpy).
• Clone es explícito, puede ser caro y puede volver a implementarse arbitrariamente.

Lo que a veces falta en la discusión de Copyvs Clonees que también afecta cómo el compilador usa movimientos vs copias automáticas. Por ejemplo:

#[derive(Debug, Clone, Copy)]
pub struct PointCloneAndCopy {
    pub x: f64,
}

#[derive(Debug, Clone)]
pub struct PointCloneOnly {
    pub x: f64,
}

fn test_copy_and_clone() {
    let p1 = PointCloneAndCopy { x: 0. };
    let p2 = p1; // because type has `Copy`, it gets copied automatically.
    println!("{:?} {:?}", p1, p2);
}

fn test_clone_only() {
    let p1 = PointCloneOnly { x: 0. };
    let p2 = p1; // because type has no `Copy`, this is a move instead.
    println!("{:?} {:?}", p1, p2);
}

El primer ejemplo ( PointCloneAndCopy) funciona bien aquí debido a la copia implícita, pero el segundo ejemplo ( PointCloneOnly) produciría un error con un uso después de mover:

error[E0382]: borrow of moved value: `p1`
  --> src/lib.rs:20:27
   |
18 |     let p1 = PointCloneOnly { x: 0. };
   |         -- move occurs because `p1` has type `PointCloneOnly`, which does not implement the `Copy` trait
19 |     let p2 = p1;
   |              -- value moved here
20 |     println!("{:?} {:?}", p1, p2);
   |                           ^^ value borrowed here after move

Para evitar el movimiento implícito, podríamos llamar explícitamente let p2 = p1.clone();.

Esto puede plantear la pregunta de cómo forzar un movimiento de un tipo que implemente el rasgo Copiar. . Respuesta corta: no puede / no tiene sentido.