The meaning of the two symbols * and &

help
1

Some books have code like this:

fn main() {
    let x = 5;
    let y = &x;
    println!("value of y is  {}",y);
    println!("value of *y is {}",*y);
}

In this example, y = &x means that y gets the memory address of x , right? And *y means that through the memory address of x , we get the value of x , which is 5, right?
Then why are the results of the two println! both 5?
Or can someone explain &x and *y more clearly,
or say that &x and *y should be seen as a whole, not understood * or & separately?

2

Because references have a transitive Display impl that simply forwards to the pointed value. If you want to print a reference as a memory address, use the {:p} specifier in the format string instead.

3

y is a reference to x. While under the hood a reference is implemented as a pointer, semantically it should act like the value it points to. For this reason the Display trait, which is the one used to print values with println, is implemented for references by forwarding to the implementation of the pointed value.

4

That's not quite as generally true as you seem to make it appear. The distinction between references and non-reference values (and in general, explicitness with regards to indirection) is a very important one in this language.

Sometimes it makes sense to simply delegate references' behavior to the referenced value, often for no more than reasons of convenience, in which case explicit impls are provided – this is exactly the story of Display. But if a reference should always just act like the pointed value, then this behavior would probably automatic and/or opt-out (which, thankfully, is not how it works).

5

It is even weirder, the following code needs a dereference on the increment on y, otherwise it will not compile

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

So when you use y in a println! the value is printed, but when you use it in an assignment you must derefence.

And this works as well:

fn main() {
    let x = 5;
    let y = &x;
    let z = y + 1;
    println!("value of z is  {}",z);
}
6

There's nothing weird in that. It's exactly the same phenomenon. There's a blanket impl<T: Display> Display for &T, but there's no such transitive impl for AddAssign on &mut T. (Probably in order not to confuse people who try to perform pointer arithmetic on references.)

7

I think there are several things going on:

  • Rust accepts &&T where it expects &T.
  • println! is a macro that implicitly takes a reference even if you don't write &.
  • Display is blanket-implemented on references too. This doesn't hold for all traits.

Generally, sometimes Rust and its std lib is lax about when to (de)reference and sometimes its not. This can be confusing at first.

1 Like
8

Yes, it is confusing. This is about the deref trait probably. But i can't find out if i32 has the deref trait or not...

9

No, the Deref trait is not involved there.

10

As explained above, it is not.

Why don't you look up the documentation, then?

By the way, Deref is not implemented for i32. Deref is usually only implemented for pointer-like types (including plain references) and "smart pointers" in the broader sense (e.g. Vec and String).

11

This example shows that &i32 indeed implements Display:

fn foo<T: std::fmt::Display>(x: T) {
    println!("{x}");
}

fn main() {
    let x = 5;
    let y = &x;
    foo(x);
    foo(y);
}

(Playground)

12

*foo is a place expression which is evident in things like *foo = 1; or &*boxed_value. They often immediately get turned into a value, which is why it might look like reading values from a location behind a reference.

2 Likes
13

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.