Why does printing a pointer print the same thing as printing the dereferenced pointer?

by

Rust usually focuses on object value (i.e. the interesting part of the contents) rather than object identity (memory addresses). The implementation of Display for &T where T implements Display defers directly to the contents. Expanding that macro manually for the String implementation of Display:

impl<'a> Display for &'a String {
    fn fmt(&self, f: &mut Formatter) -> Result {
        Display::fmt(&**self, f)
    }
}

That is, it is just printing its contents directly.

If you care about object identity/the memory address, you can use the Pointer formatter, {:p}:

fn main() {
    let x = 1;
    let ptr_y = &x;
    println!("x: {}, ptr_y: {}, address: {:p}", x, ptr_y, ptr_y);
}

Output:

x: 1, ptr_y: 1, address: 0x7fff4eda6a24

playground

More Related Contents:

  1. What is a “fat pointer”?
  2. Why is the return type of Deref::deref itself a reference?
  3. Meaning of ‘&variable’ in arguments/patterns
  4. How to check if two variables point to the same object in memory?
  5. Understanding and relationship between Box, ref, & and *
  6. X does not implement Y (… method has a pointer receiver)
  7. How do I do a literal *int64 in Go?
  8. Using the extra 16 bits in 64-bit pointers
  9. What is the relation between auto-dereferencing and deref coercion?
  10. ” is pointer to interface, not interface” confusion
  11. Copying a struct containing pointers to CUDA device
  12. Pointer Arithmetic: ++*ptr or *ptr++?
  13. What does “`str` does not have a constant size known at compile-time” mean, and what’s the simplest way to fix it?
  14. My object is not updated even if I use the pointer to a type to update it
  15. Slicing a slice pointer passed as argument
  16. Cast a struct pointer to interface pointer in Golang
  17. Can the pointer in a struct pointer method be reassigned to another instance?
  18. Why does Go forbid taking the address of (&) map member, yet allows (&) slice element?
  19. Dereferencing a map index in Golang
  20. Should pointer comparisons be signed or unsigned in 64-bit x86?
  21. Why can’t I treat an array like a pointer in C?
  22. Why should constructor of Go return address?
  23. Why does a mutable borrow of a closure through DerefMut not work?
  24. Range references instead values
  25. Passing by reference and value in Go to functions
  26. Kotlin function parameter: Val cannot be reassigned
  27. Go equivalent of a void pointer in C
  28. Difference between dereferencing pointer and accessing array elements
  29. Difference between pointer to pointer and pointer to array?
  30. Test for nil values in nested stucts

Leave a Comment