Discussion :

[unoomad]

Bonjour/bonsoir, je suis entrain d'apprendre Rust n'ayant jamais appris de langage de bas niveau je bloque sur certaine notion notamment des pointeurs.

Voici un exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
fn main() {
    let trois  = &3;
    let quatre   = &4;
    println!("3 + 4 = {}", *three + *four);
}

Ce que je comprends ici c'est que dans les variables "trois" et "quatre" on stocke des références vers d'autre valeure comme sur cette image ci-dessous.



Mais sur cette ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 println!("3 + 4 = {}", *three + *four);

Que je mette des astérics ou non j'obtiens quand même la valeure 7.

En fait je ne comprends pas très bien en général comment utiliser le signe & ...

Merci cordialement unoomad.

[imperio]

Il n'y a pas vraiment de notion de pointeur en Rust. Le caractère '&' signifie "référence sur". En gros, dans ton code tu ne fais qu'assigner des références de valeur constante. Tu pourrais même écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
fn main() {
    let trois  = &3;
    let quatre   = &4;
    println!("3 + 4 = {}", trois + quatre);
}

Dans le cas présent, ça reviendra au même. D'ailleurs, tout comme je l'ai écrit dans le cours :

• Une référence ne doit pas "vivre" plus longtemps que la variable qu'elle référence.
• On peut avoir autant de référence constante que l'on veut sur une variable.
• On ne peut avoir qu'une seule référence mutable sur une variable.
• On ne peut avoir une référence mutable que sur une variable mutable.

Le Rust est un langage permettant de faire du bas niveau sans tous les inconvénients que cela peut engendrer. Tu ne verras (normalement) jamais de pointeurs.

[unoomad]

Je n'ai toujours pas très bien saisit les références par exemple ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
fn main() {
    let trois  = &3;   // ça veut dire que la variable 'trois' reference sur 3 ?
    let quatre   = &4;
    println!("3 + 4 = {}", trois + quatre);
}

Mais en fait je comprends pas trop pourquoi on utilise des references et quand les utiliser.

Il y a autre chose ou j'ai eu un problème j'ai vu que chaque variable a un propriétaire ça veut dire quoi exactement ? J'ai testé ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
fn main() {
    let x = 5;           // ici ça veux dire que 5 appartient a x ?
    let x2 = x;         // et ici ça veux dire qu"on lègue la propriété de la valeur 5 a x2 ?
    println!("{}", x); // ici ça passe 
    
    let v = vec![1, 2, 3];
    let v2 = v;
    println!("v[0] is: {}", v[0]); //mais ici : error ! "use of moved value"
}

[imperio]

Les propriétés sont les choses les plus difficiles à comprendre en Rust. Prenons un exemple simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
let x = 5; // x vaut 5
let y = &x; // x appartient à y
let z = &6; // une valeur constante valant 6 est créée et appartient à z

Si tu peux modifier un vecteur dans une fonction sans en perdre la propriété, il te faudra utiliser '&' pour envoyer une référence et non pas la propriété de l'objet. Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
let v = vec!(1, 2);

une_fonction(v); // ici tu perds la propriété de v car tu la donnes à la fonction
une_fonction(&v); // ici tu "prêtes" v, mais tu récupères sa propriété dès que tu sors de la fonction

Comme je l'ai dit, c'est assez difficile à comprendre au début. En Rust, chaque objet a un propriétaire. Je te conseille d'essayer de bien relire le chapitre qui en parle. N'hésite pas si tu as besoin de plus de précision.

[unoomad]

Je pense avoir compris les bases les notions de propriété ne marchent que sur les types qui n'implémentent pas le trait Copy c'est ça ?


Mais ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
let x = 5; // x vaut 5
let y = &x; // x appartient à y
let z = &6; // une valeur constante valant 6 est créée et appartient à z

ça sert a quoi de prendre des références des types qui implémentent le trait Copy si on fait ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
let x = 5; 
let y = x;
let z = 6;

ça reviens pas au même ? et puis le "*" sert a quoi si dans cet exemple on peut faire ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
println!("3 + 4 = {}", trois + quatre);

et ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
println!("3 + 4 = {}", *trois + *quatre);

[imperio]

Si un objet implémente le trait Copy, si tu utilises l'opérateur '=', la mémoire est copiée dans le nouvel objet. Pour un i32 ou un petit "objet", c'est pas gênant. Maintenant imagine si tu fais ça sur une HashMap de plusieurs mégas : ça sera catastrophique.

L'opérateur '*' sert à déréférencer un objet. Encore une fois, dans le cas des i32 (ou équivalent), ça ne sert à rien.

[imperio]

J'ajoute à ma réponse précédente (j'ai oublié de le préciser) qu'il est inutile de déréférencer un i32 tout simplement parce que le trait Add a été implémenté dessus. Jettes-y un coup d'oeil, je pense que tu comprendras mieux.

[unoomad]

J'ai compris !! du moins je pense avoir compris, maintenant je regarde les lifetimes, par contre ici j'ai vraiment rien compris dans cette partie je ne comprends pas l'effet que ça fait en ajoutant ça : "&'a",
il faut utiliser "&'a" quand une variable vit plus longtemps que celui qu'elle référence ? dit moi si je déborde un peu sur le sujet comme ça je pourrais créer un autre topic.

[imperio]

Ça se rattache donc ça devrait être bon. Les lifetimes sont globalement devenues obsolètes puisque le compilateur arrive à les déduire sans aide la plupart du temps. Je sais plus si j'ai donné cet exemple dans le cours mais voilà :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct UneStruct {
    nom: String
}

// Avant on devait écrire ça :
impl UneStruct {
    fn get_nom<'a>(&self) -> &'a str {
        &nom
    }
}

// maintenant on peut se contenter d'écrire ça :
impl UneStruct {
    fn get_nom(&self) -> &str {
        &nom
    }
}

Le seul type de lifetime que j'ai croisé récemment était 'static.

Pour en revenir à l'explication de base, le 'a permet d'associer une lifetime (tu pourrais écrire 'z si l'envie te chante hein) à une variable pour "faciliter la tâche" au compilateur.

[unoomad]

Je pense avoir compris la chose j'ai vu des choses comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
fn min_life<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
    if *x > *y {
        x
    } else {
        y
    }
}

fn main() {

let x = 10;
let y = 20;
let res = min_life(&x,&y);

println!("{}", res);
    
}

ou apparament le lifetime devait être renseigné merci pour t'es conseil,je poserais surement des questions dans le futur. Maintenant il faut que je trouve quelque chose a faire avec ce que j'ai appris je trouve ce language fantastique.