Rust utilise un vérificateur d'emprunt pour appliquer ses règles de propriété et s'assurer que les programmes sont sécurisés en mémoire. Les règles de propriété dictent comment Rust gère la mémoire sur la pile et le tas.
Lorsque vous écrivez des programmes Rust, vous devrez utiliser des variables sans changer la propriété de la valeur associée. Rust fournit un mécanisme d'emprunt robuste pour encourager la flexibilité et la réutilisation du code.
Qu'est-ce qu'emprunter dans Rust ?
Emprunter c'est accéder à la valeur d'une variable sans s'approprier la variable en faisant référence au propriétaire. Le vérificateur d'emprunt s'assure que la référence est valide et que les données ne sont pas supprimées à l'aide d'une construction appelée durées de vie.
Une durée de vie est la durée d'existence d'une variable. Les durées de vie commencent à la création de la variable et se terminent à la destruction de la variable. Vous pouvez emprunter la propriété d'une variable, et lorsque la référence empruntée est hors de portée, la propriété revient à la variable propriétaire. Emprunter, c'est un peu comme
pointeurs que vous trouverez dans des langages comme C++ et Go. Mais le compilateur Rust utilise le vérificateur d'emprunt pour s'assurer que les programmes sont sécurisés en mémoire.Un exemple d'emprunt en Rust
Vous pouvez emprunter la propriété d'une variable en référençant le propriétaire à l'aide du symbole esperluette (&).
fnprincipale() {
laisser x = Chaîne de caractères::de("bonjour"); // x possède "hello"
laisser y = &x; // y référence x, emprunte "hello"
imprimez !("{}", X);
imprimez !("{}", y)
}
Sans emprunt par référencement, le programme paniquerait. Cela violerait la règle de propriété selon laquelle une valeur peut avoir un propriétaire et deux variables ne peuvent pas pointer vers le même emplacement mémoire. L'emprunt peut être très utile dans les fonctions. Voici un exemple d'emprunt dans une fonction, pour garder la propriété tout en appelant d'autres fonctions qui prennent des variables locales comme arguments.
fnprint_even(vecteur: &Vec<i32>) {
pour valeurs dans vecteur {
si valeurs % 2 == 0 {
imprimez !("{}", valeurs);
}
}
}
La print_even La fonction fait référence à un vecteur d'entiers 32 bits comme argument. Il imprime ensuite des lignes de valeurs multiples de deux dans le vecteur en utilisant une boucle for et le println! macro.
fnprincipale() {
laisser nombre_vecteur = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
print_even(&number_vector); // la propriété est empruntée, pas déplacée
imprimez !("La fonction principale conserve la propriété du vecteur numérique{: ?}", number_vector)
}
La fonction main déclare la variable number_vector et lui affecte un vecteur d'entiers 32 bits. Il appelle ensuite la fonction print_even et lui transmet une référence à la nombre_vecteur variable à l'aide du symbole esperluette.
La fonction principale conserve la propriété du nombre_vecteur variable, il peut continuer à utiliser la valeur à son emplacement mémoire.
Emprunter et faire muter des références
Les fonctions peuvent également modifier des variables empruntées en utilisant des références mutables à celles-ci, avant de rendre la propriété.
Cependant, contrairement aux variables régulières qui peuvent être définies sur mutable à l'aide du mot-clé mut, vous devez préfixer les références mutables avec le symbole esperluette.
Avant de faire des références mutables, la variable que vous souhaitez modifier doit être mutable.
fnremove_value(vecteur: &muetVec<i32>) -> &Vec<i32> {
vectr.remove(4);
revenir vecteur
}
La remove_value La fonction prend la référence d'un vecteur mutable d'entiers 32 bits. Il renvoie un vecteur d'entiers 32 bits après avoir supprimé la valeur du vecteur dans le quatrième index.
fnprincipale() {
laissermuet chiffres = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
remove_value(&muet chiffres); // référence modifiable ici
imprimez !("{: ?}", chiffres );
}
La fonction modifie la chiffres vector en appelant remove_value et en passant la référence mutable d'un vecteur comme argument. Lors de l'impression du vecteur, le quatrième index précédent du vecteur n'existe pas.
Notez que l'argument est une référence à un vecteur mutable.
Il est important de comprendre la propriété et l'emprunt
Vous devrez comprendre la propriété et l'emprunt pour écrire un code Rust efficace et sécurisé en mémoire qui se compile et s'exécute. Si votre code ne respecte pas les règles de propriété, le vérificateur d'emprunt le détectera. Vous devrez rendre votre programme sécurisé en mémoire pour que Rust le compile.
Le vérificateur d'emprunt est ennuyeux lorsque vous débutez avec Rust. Mais, au fur et à mesure que vous écrivez plus de code Rust, vous vous y habituerez et acquerrez de l'expérience dans l'écriture de code Rust sécurisé en mémoire.
