rust - Hace println! pedir prestado o ser dueño de la variable?

ownership

Question

Estoy confundido con los préstamos y la propiedad. En la documentación de Rust sobre referencias y préstamos

let mut x = 5;
{
    let y = &mut x;
    *y += 1;
}
println!("{}", x);

Ellos dicen

println! puede pedir prestado x .

Estoy confundido por esto. Si println! pide prestado x , ¿por qué pasa x no &x ?

Intento ejecutar este código a continuación

fn main() {
    let mut x = 5;
    {
        let y = &mut x;
        *y += 1;
    }
    println!("{}", &x);
}

¡Este código es idéntico al código anterior excepto que paso &x para println! . Imprime ''6'' en la consola, lo cual es correcto y es el mismo resultado que el primer código.

Answer 1

¡Se print! macros print! , println! , eprint! , eprintln! , write! , writeln! y format! son un caso especial, no se comportan como lo hacen las cosas normales por razones de conveniencia. El hecho de que tomen referencias en silencio es parte de esa diferencia.

fn main() {
    let x = 5;
    println!("{}", x);
}

Ejecútelo a través de rustc -Z unstable-options --pretty expanded en el compilador nocturno y ¡podemos ver qué println! se expande a:

#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std as std;
fn main() {
    let x = 5;
    ::io::_print(::std::fmt::Arguments::new_v1(
        {
            static __STATIC_FMTSTR: &''static [&''static str] = &["", "/n"];
            __STATIC_FMTSTR
        },
        &match (&x,) {
            (__arg0,) => {
                [
                    ::std::fmt::ArgumentV1::new(__arg0, ::std::fmt::Display::fmt),
                ]
            }
        },
    ));
}

Ordenado mucho, es esto:

use std::fmt;
use std::io;

fn main() {
    let x = 5;
    io::_print(fmt::Arguments::new_v1(
        &["", "/n"];
        &[fmt::ArgumentV1::new(&x, fmt::Display::fmt)],
    ));
}

Tenga en cuenta la &x .

Si escribe println!("{}", &x) , entonces está tratando con dos niveles de referencias; esto tiene el mismo resultado porque hay una implementación de std::fmt::Display para &T donde T implementa Display (se muestra como impl<''a, T> Display for &''a T where T: Display + ?Sized ) que solo lo pasa a través. También podría escribir &&&&&&&&&&&&&&&&&&&&&&&x .