reference - traducir - traductor de ingles online

No puede salir del contenido prestado/no puede salir de una referencia compartida

Question

No entiendo que el error cannot move out of borrowed content . Lo he recibido muchas veces y siempre lo he resuelto, pero nunca he entendido por qué.

Por ejemplo:

for line in self.xslg_file.iter() {
    self.buffer.clear();

    for current_char in line.into_bytes().iter() {
        self.buffer.push(*current_char as char);
    }

    println!("{}", line);
}

produce el error:

error[E0507]: cannot move out of borrowed content
  --> src/main.rs:31:33
   |
31 |             for current_char in line.into_bytes().iter() {
   |                                 ^^^^ cannot move out of borrowed content

En versiones más recientes de Rust, el error es

error[E0507]: cannot move out of `*line` which is behind a shared reference
  --> src/main.rs:31:33
   |
31 |             for current_char in line.into_bytes().iter() {
   |                                 ^^^^ move occurs because `*line` has type `std::string::String`, which does not implement the `Copy` trait

Lo resolví mediante la line clonación:

for current_char in line.clone().into_bytes().iter() {

No entiendo el error incluso después de leer otras publicaciones como:

• No se puede tomar prestado el archivo de & mut self (mensaje de error: no se puede salir del contenido prestado)
• Cambiar un nodo en un árbol en Rust

¿Cuál es el origen de este tipo de error?

Answer 1

Veamos la firma de into_bytes :

fn into_bytes(self) -> Vec<u8>

Esto toma self , no una referencia a self ( &self ). Eso significa que self se consumirá y no estará disponible después de la llamada. En su lugar, obtienes un Vec<u8> . El prefijo into_ es una forma común de denotar métodos como este.

No sé exactamente qué devuelve su método iter() , pero supongo que es un iterador sobre &String , es decir, devuelve referencias a un String pero no le otorga la propiedad de ellos. Eso significa que no puede llamar a un método que consume el valor .

Como has encontrado, una solución es usar clone . Esto crea un objeto duplicado que usted posee y puede llamar a into_bytes . Como mencionan otros comentaristas, también puede usar as_bytes que toma &self , por lo que funcionará con un valor prestado. Cuál debe usar depende de su objetivo final para lo que hace con el puntero.

En la imagen más grande, todo esto tiene que ver con la noción de propiedad . Ciertas operaciones dependen de poseer el artículo, y otras operaciones pueden salirse con el préstamo del objeto (quizás mutablemente). Una referencia ( &foo ) no otorga la propiedad, es solo un préstamo.

¿Por qué es interesante usar self lugar de &self en los argumentos de una función?

La transferencia de propiedad es un concepto útil en general: cuando termino con algo, alguien más puede tenerlo. En Rust, es una forma de ser más eficiente. Puedo evitar asignar una copia, darle una copia y luego tirar mi copia. La propiedad es también el estado más permisivo; si poseo un objeto, puedo hacer con él lo que desee.

Aquí está el código que creé para probar:

struct IteratorOfStringReference<''a>(&''a String);

impl<''a> Iterator for IteratorOfStringReference<''a> {
    type Item = &''a String;

    fn next(&mut self) -> Option<Self::Item> {
        None
    }
}

struct FileLikeThing {
    string: String,
}

impl FileLikeThing {
    fn iter(&self) -> IteratorOfStringReference {
        IteratorOfStringReference(&self.string)
    }
}

struct Dummy {
    xslg_file: FileLikeThing,
    buffer: String,
}

impl Dummy {
    fn dummy(&mut self) {
        for line in self.xslg_file.iter() {
            self.buffer.clear();

            for current_char in line.into_bytes().iter() {
                self.buffer.push(*current_char as char);
            }

            println!("{}", line);
        }
    }
}

fn main() {}