[rust] dereferencement et adresse memoire

Salut, comment verifier si il y a ou non un changement d’adresse memoire de ma variable text (label / valeur sous jacente dans la RAM) lors de l’operation suivante:

    fn main(){
        let mut text = String::from("test");
        read_test(&mut text); // on passe la variable text par référence en spécifiant qu'elle est mutable
    }
    pub fn read_test(text: &mut String){
        *text = String::from("new_test"); // le signe * devant "text" signifie, comme en C/C++, que je déréférence le String text pour lui assigner sa nouvelle valeur.
    }

Salut,

Je comprends pas bien ce que tu demandes. La chaîne elle-même a une partie dans la pile, qui va être en haut au-moment où tu appelles la fonction, qui pointe vers une partie du tas qui contient le texte lui-même. Celui-ci va peu bouger, à moins d’agrandir tellement la chaîne que tu es obligé de la déplacer en mémoire. Mais en fait ça tu t’en fous pas mal, et ça n’a pas grand chose à voir avec le déréférencement par ailleurs.

Salut. J’ai une question différente pour toi, pourquoi veux-tu faire ça ("gérer" la mémoire explicitement alors que tu fais du Rust) ?
Pour ta question soit il y a quelque chose dans std::mem pour ce que tu veux faire, soit tu vas devoir passer par du unsafe.

La page de doc qui va bien. Le Rust Book est vraiment cool, faut le lire.

C’est par curiosité et pour comprendre ce qui se passe dans la mémoire. Pour l' histoire du deferencement, ce passage éclaire un peu:

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

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

Listing 15–6: Using the dereference operator to follow a reference to an i32 value

The variable x holds an i32 value, 5. We set y equal to a reference to x. We can assert that x is equal to 5. However, if we want to make an assertion about the value in y, we have to use *y to follow the reference to the value it’s pointing to (hence dereference). Once we dereference y, we have access to the integer value y is pointing to that we can compare with 5.

If we tried to write assert_eq!(5, y); instead, we would get this compilation error:

error[E0277]: can't compare `{integer}` with `&{integer}`
 --> src/main.rs:6:5
  |
6 |     assert_eq!(5, y);
  |     ^^^^^^^^^^^^^^^^^ no implementation for `{integer} == &{integer}`
  |
  = help: the trait `std::cmp::PartialEq<&{integer}>` is not implemented for
  `{integer}`

Comparing a number and a reference to a number isn’t allowed because they’re different types. We must use the dereference operator to follow the reference to the value it’s pointing to.

https://doc.rust-lang.org/stable/book/ch15–02-deref.html