Emprunt et références de la rouille

Chaque valeur dans une rouille a une variable connue sous le nom de son propriétaire. La règle de propriété unique de la rouille stipule qu'il ne peut y avoir qu'un seul propriétaire à la fois.

Cependant, nous pouvons rencontrer des cas où nous devons utiliser et modifier temporairement une valeur. Nous pouvons accomplir cela en utilisant l'emprunt. L'emprunt est un concept qui nous permet d'emprunter une valeur, de l'utiliser et une fois que nous aurons terminé, renvoyez-le à son propriétaire dans le même état que lorsque nous l'avons emprunté. Cela signifie que l'emprunt ne modifie pas la valeur d'origine.

Nous empruntons une valeur en le faisant référence à l'aide de son adresse mémoire et de l'opérateur. Nous pouvons ensuite transmettre la référence à une fonction et utiliser la valeur comme nous le voyons.

Règles de référence

Il y a deux règles pour travailler avec des références en rouille:

1. Vous pouvez avoir des références mutables ou de nombreuses références immuables à la fois.
2. Toutes les références doivent être valides.

Référence de la rouille et valeur d'emprunt

Dans Rust, nous utilisons l'opérateur pour référencer une adresse de valeur. Un exemple de code est comme indiqué ci-dessous:

fn main ()
Laissez String = String :: From ("Hello");
Selt str_len = get_str_length (& string);
println!("Longueur de chaîne: ", str_len);

fn get_str_length (string: & string) -> usize
chaîne de retour.Len ();

Dans le code ci-dessus, nous définissons une variable appelée «String». Selon les règles de propriété, cette variable possède la valeur «bonjour».

Cependant, nous devons utiliser cette variable dans la fonction. Puisqu'une valeur ne peut avoir qu'un propriétaire à un moment donné, l'utiliser à l'intérieur de la fonction transférera la propriété. Puisque nous ne voulons pas que la propriété soit transférée à la fonction, nous empruntions la valeur en utilisant en faisant référence à son propriétaire.

Notez que nous ajoutons l'opérateur dans le type de paramètre de fonction. Cela indique à Rust que nous faisons référence à la valeur et que nous devrions le rendre après l'achèvement.

Références mutables

Si nous essayons de modifier une valeur empruntée, Rust entraînera une erreur. Prenez l'exemple ci-dessous:

fn main ()
Laissez String = String :: From ("Hello");
change_value (& string);

fn change_value (string: & string)
chaîne.push_str ("monde!")

L'exécution du code ci-dessus doit renvoyer une erreur comme:

En effet, les références sont immuables par défaut. Par conséquent, nous ne pouvons pas modifier une valeur empruntée.

Nous pouvons avoir une référence mutable qui nous permet de modifier une valeur empruntée. Considérez l'exemple de code ci-dessous:

fn main ()
Laissez mut string = string :: from ("Hello");
change_value (& mut string);

fn Change_Value (String: & mut String)
chaîne.push_str ("monde!")

Dans l'exemple ci-dessus, nous définissons la variable «String» t être mutable. Nous créons ensuite une référence mutable en utilisant la chaîne & mut dans l'appel de fonction. Notez que le paramètre de fonction accepte une référence mutable, permettant à la fonction de modifier la valeur empruntée.

Remarque: Comme mentionné, vous ne pouvez avoir qu'une seule référence mutable à un moment particulier. Tenter de créer plus d'une référence mutable mettra une erreur comme indiqué:

fn main ()
Laissez mut string = string :: from ("Hello");
Soit String2 = & mut String;
Soit String3 = & mut String;
println!(" ", string2, string3);

fn Change_Value (String: & mut String)
chaîne.push_str ("monde!")

Le code ci-dessus doit renvoyer une erreur comme indiqué:

Cette fonctionnalité peut aider à prévenir les conditions de course lors de l'emprunt et de la référence.

Conclusion

Cet article fournit une compréhension de base de l'utilisation et du travail avec les fonctionnalités d'emprunt et de référence. Vous pouvez vérifier les documents pour explorer plus loin.