Discussion :

[bombseb]

Bonjour, je ne comprend pas comment fonctionne la boucle for dans ces deux exemples...

Dans l'exemple 1 la variable element n'est pas une référence n'est-ce pas ? donc la propriété de cette variable est transmise à la variable le_plus_grand dans le if ? Donc d'après moi la valeur de retour n'est pas une référence bien que dans la signature de la fonction on a défini &T comme valeur de retour...
Dans l'exemple 2 la variable element est une référence et donc la propriété de cette variable est transmise à la variable le_plus_grand dans le if ?

pfff je m'emmele les pinceaux avec ces histoires de réference / pas références

exemple 1 :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
fn le_plus_grand<T: PartialOrd>(liste: &[T]) -> &T {
    let mut le_plus_grand = &liste[0];
 
    for element in liste {
        if element > le_plus_grand {
            le_plus_grand = element;
 
        }
    }
 
    le_plus_grand
}

exemple 2 :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
fn le_plus_grand<T: PartialOrd + Copy>(liste: &[T]) -> T {
    let mut le_plus_grand = liste[0];
 
    for &element in liste {
        if element > le_plus_grand {
            le_plus_grand = element;
        }
    }
 
    le_plus_grand
}

[Pyramidev]

Bonjour,

Dans l'exemple 1 la variable element n'est pas une référence n'est-ce pas ? donc la propriété de cette variable est transmise à la variable le_plus_grand dans le if ? Donc d'après moi la valeur de retour n'est pas une référence bien que dans la signature de la fonction on a défini &T comme valeur de retour...
[…]
exemple 1 :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
fn le_plus_grand<T: PartialOrd>(liste: &[T]) -> &T {
    let mut le_plus_grand = &liste[0];
 
    for element in liste {
        if element > le_plus_grand {
            le_plus_grand = element;
 
        }
    }
 
    le_plus_grand
}

Si, element est une référence de type &T.

Le type slice &[T] implémente le trait IntoIterator et les éléments sont de type &T : https://doc.rust-lang.org/std/primit...'a+%5BT%5D

En outre, quand tu peux comparer deux éléments de type T entre eux, tu peux aussi comparer deux éléments de type &T entre eux. C'est pour ça que le compilateur accepte l'expression element > le_plus_grand.
Plus généralement, si un type A peut être comparé avec un type B, alors &A peut être comparé avec &B. C'est une règle codée directement dans la bibliothèque standard : https://doc.rust-lang.org/std/cmp/tr...6B%3E-for-%26A

Dans l'exemple 2 la variable element est une référence et donc la propriété de cette variable est transmise à la variable le_plus_grand dans le if ?
[…]
exemple 2 :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
fn le_plus_grand<T: PartialOrd + Copy>(liste: &[T]) -> T {
    let mut le_plus_grand = liste[0];
 
    for &element in liste {
        if element > le_plus_grand {
            le_plus_grand = element;
        }
    }
 
    le_plus_grand
}

Ce code équivaut à :

Code :

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

1
2
3
4
5
6
7
8
9
10
fn le_plus_grand<T: PartialOrd + Copy>(liste: &[T]) -> T {
    let mut le_plus_grand = liste[0];
    for x in liste {
        let &element = x;
        if element > le_plus_grand {
            le_plus_grand = element;
        }
    }
    le_plus_grand
}

qui équivaut à :

Code :

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

1
2
3
4
5
6
7
8
9
10
fn le_plus_grand<T: PartialOrd + Copy>(liste: &[T]) -> T {
    let mut le_plus_grand = liste[0];
    for x in liste {
        let element = *x;
        if element > le_plus_grand {
            le_plus_grand = element;
        }
    }
    le_plus_grand
}

La variable que j'ai appelée x est bien une référence de type &T. element est donc de type T.

[bombseb]

Hello,

D'après ce que tu dis, les deux lignes suivantes font la même chose ?

Code :

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

let &element = x;

Code :

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

let element = *x;

La première je la trouve étrange...je préfère la deuxième que je trouve plus claire.
Pour moi &element veut dire "référence vers la variable element", donc faire "référence vers la variable element est égale à x" ca n'a pas de sens...

Bon si j'ai bien compris ce que tu m'a dit, lorsqu'on fait une boucle for sur un vecteur, les éléments récupérés sont des références. Est-ce que c'est aussi valable sur les vecteur ?
D'ailleurs dans cette fonction le_plus_grand pour quoi ne pas envoyer plutôt en paramètre le type std:vec:Vec ?

[Pyramidev]

Bonjour,

D'après ce que tu dis, les deux lignes suivantes font la même chose ?

Code :

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

let &element = x;

Code :

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

let element = *x;

La première je la trouve étrange...je préfère la deuxième que je trouve plus claire.

Oui, c'est pareil.

Dans ton exemple 2, quand tu as écrit :

Code :

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

1
2
3
for &element in liste {
    ....
}

c'était un cas particulier de :

Code :

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

1
2
3
for pattern in expression {
    ....
}

De même, let &element = x; est un cas particulier de let pattern = expression;. Ils obéissent aux mêmes règles.

Code :

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

1
2
3
for pattern in expression {
    ....
}

équivalent à :

Code :

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

1
2
3
4
for x in expression {
    let pattern = x;
    ....
}

(si le code représenté par ... n'utilise pas x).

Pour moi &element veut dire "référence vers la variable element", donc faire "référence vers la variable element est égale à x" ca n'a pas de sens...

On peut donner à let &element = x; le sens suivant : dans la suite du code, l'adresse &element est égale à l'adresse stockée dans la variable x.
[EDIT 2023-10-21-12h45]
Au temps pour moi. Les adresses ne sont pas égales car element est une copie de *x stockée ailleurs en mémoire.

Code :

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

1
2
3
4
5
6
7
8
9
fn test<T: Copy>(x: &T) -> bool {
    let &element = x;
    std::ptr::eq(&element, x)
}
 
fn main() {
    let foo = 42;
    println!("{}", test(&foo)); // false
}

[/EDIT]

Bon si j'ai bien compris ce que tu m'a dit, lorsqu'on fait une boucle for sur un vecteur, les éléments récupérés sont des références. Est-ce que c'est aussi valable sur les vecteur ?

Il y a vraisemblablement un lapsus dans la question, mais je peux quand même répondre :

• Quand on fait une boucle for sur une expression de type &Vec<T>, on itère sur des éléments de type &T : https://doc.rust-lang.org/std/vec/st...+Vec%3CT,+A%3E
• Quand on fait une boucle for sur une expression de type &mut Vec<T>, on itère sur des éléments de type &mut T : https://doc.rust-lang.org/std/vec/st...+Vec%3CT,+A%3E
• Quand on fait une boucle for sur une expression de type Vec<T>, on itère sur des éléments de type T : https://doc.rust-lang.org/std/vec/st...-Vec%3CT,+A%3E

La même logique s'applique aux tableaux :

• Quand on fait une boucle for sur une expression de type &[T; N], on itère sur des éléments de type &T : https://doc.rust-lang.org/std/primit...9;a+%5BT;+N%5D
• Quand on fait une boucle for sur une expression de type &mut [T; N], on itère sur des éléments de type &mut T : https://doc.rust-lang.org/std/primit...mut+%5BT;+N%5D
• Quand on fait une boucle for sur une expression de type [T; N], on itère sur des éléments de type T : https://doc.rust-lang.org/std/primit...for-%5BT;+N%5D

La même logique s'applique aux slices :

• Quand on fait une boucle for sur une expression de type &[T], on itère sur des éléments de type &T : https://doc.rust-lang.org/std/primit...&#39;a+%5BT%5D
• Quand on fait une boucle for sur une expression de type &mut [T], on itère sur des éléments de type &mut T : https://doc.rust-lang.org/std/primit...;a+mut+%5BT%5D

D'ailleurs dans cette fonction le_plus_grand pour quoi ne pas envoyer plutôt en paramètre le type std:vec:Vec ?

Une référence vers un vecteur peut être convertie en slice. Donc, si une fonction prend en paramètre un slice, alors elle sera plus réutilisable que si elle prenait en paramètre une référence vers un vecteur.
En pratique, une fonction ne devrait donc jamais prendre en paramètre une référence vers un vecteur.
Par contre, une fonction peut prendre en paramètre un vecteur (pas une référence) si elle veut le "manger". C'est par exemple le cas de String::from_utf8. Sous le capot, String contient un Vec<u8>.

[bombseb]

Hello,

Merci à toi d'avoir pris le temps de me répondre, je vais potasser tout ca