Does println! borrow or own the variable?

by

The macros print!, println!, eprint!, eprintln!, write!, writeln! and format! are a special case and implicitly take a reference to any arguments to be formatted.

These macros do not behave as normal functions and macros do for reasons of convenience; the fact that they take references silently is part of that difference.

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

Run it through rustc -Z unstable-options --pretty expanded on the nightly compiler and we can see what println! expands to:

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
fn main() {
    let x = 5;
    {
        ::std::io::_print(::core::fmt::Arguments::new_v1(
            &["", "\n"],
            &match (&x,) {
                (arg0,) => [::core::fmt::ArgumentV1::new(
                    arg0,
                    ::core::fmt::Display::fmt,
                )],
            },
        ));
    };
}

Tidied further, it’s this:

use std::{fmt, io};

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

Note the &x.

If you write println!("{}", &x), you are then dealing with two levels of references; this has the same result because there is an implementation of std::fmt::Display for &T where T implements Display (shown as impl<'a, T> Display for &'a T where T: Display + ?Sized) which just passes it through. You could just as well write &&&&&&&&&&&&&&&&&&&&&&&x.

More Related Contents:

  1. Temporarily move out of borrowed content
  2. Do mutable references have move semantics?
  3. What are move semantics in Rust?
  4. Is it possible to return either a borrowed or owned type in Rust?
  5. Type mismatches resolving a closure that takes arguments by reference
  6. What are non-lexical lifetimes?
  7. What are Rust’s exact auto-dereferencing rules?
  8. Why is a trait not implemented for a type that clearly has it implemented?
  9. How can I include a module from another file from the same project?
  10. What does “Sized is not implemented” mean?
  11. Deriving a trait results in unexpected compiler error, but the manual implementation works
  12. How do I implement a trait I don’t own for a type I don’t own?
  13. Rust proper error handling (auto convert from one error type to another with question mark)
  14. Why is a borrow still held in the else block of an if let?
  15. How to create a static string at compile time
  16. How to call a method when a trait and struct use the same method name?
  17. What does “cannot move out of index of” mean?
  18. What is the syntax: `instance.method::()`?
  19. “expected type parameter, found struct”
  20. Is it possible to declare the type of the variable in Rust for loops?
  21. Cannot create a generic function that uses a literal zero
  22. Is there a way to combine multiple traits in order to define a new trait? [duplicate]
  23. How can I store a pattern in a variable in Rust?
  24. Why does a mutable borrow of a closure through DerefMut not work?
  25. How to switch between Rust toolchains?
  26. Why can Serde not derive Deserialize for a struct containing only a &Path?
  27. Use of undeclared type or module `std` when used in a separate module
  28. How do I cope with lazy iterators?
  29. Lazy sequence generation in Rust
  30. Is there a way to get the field names of a struct in a macro?

Leave a Comment