Les langages de programmation diffèrent dans la façon dont ils gèrent la mémoire et appliquent les règles de gestion de la mémoire. Go et Python utilisent des ramasse-miettes, afin que les développeurs puissent se concentrer sur l'écriture de code. C et C++ donnent aux programmeurs la responsabilité de gérer la mémoire à un niveau inférieur.
Rust traite la gestion de la mémoire différemment, en utilisant des concepts qu'il appelle propriété et emprunt. Il utilise un "vérificateur d'emprunt" pour renforcer efficacement la sécurité de la mémoire.
Qu'est-ce que la propriété ?
La propriété est une fonctionnalité et une convention de Rust qui permet d'assurer la sécurité de la mémoire des programmes sans ramasse-miettes. C'est une autre façon d'aborder le problème des fuites de mémoire dans votre code.
Le compilateur Rust vérifie si un programme respecte les règles de propriété au moment de la compilation. Si le programme suit ces règles, il peut s'exécuter. Si ce n'est pas le cas, le compilateur refuse de produire un exécutable.
Rust vérifie les règles de propriété en utilisant le vérificateur d'emprunt. Le vérificateur d'emprunt vérifie le modèle de propriété et décide si une valeur en mémoire (pile ou tas) est hors de portée ou non. Si une valeur est hors de sa portée, elle n'est pas accessible aux autres parties du programme à moins qu'elle ne soit empruntée.
Les règles de propriété
Dans Rust, chaque variable possède la valeur avec laquelle elle est initialisée, et il ne peut y avoir qu'un seul propriétaire. Une fois que le propriétaire est hors de portée, la valeur est supprimée. Il est important de comprendre les détails des règles de propriété.
La première règle de propriété est que chaque variable possède sa valeur initialisée.
laisser propriétaire = Chaîne de caractères::D'un");
La propriétaire la variable ci-dessus possède la chaîne une et, contrairement aux langages tels que Python et Go, cette valeur sera supprimée lors de la réaffectation de variable.
La deuxième règle de propriété est que deux variables ne peuvent pas pointer vers le même emplacement mémoire; chaque valeur ne peut avoir qu'un seul propriétaire.
laisser nouveau_propriétaire = propriétaire ;
La nouveau propriétaire la variable possède maintenant la valeur stockée à l'emplacement mémoire de la propriétaire variable. Si vous essayez d'utiliser le propriétaire variable, le compilateur paniquera et refusera de générer un exécutable.
Dans la plupart des langages qui utilisent des ramasse-miettes, deux variables peuvent pointer vers le même emplacement mémoire. Voici un exemple de code JavaScript équivalent :
laisser propriétaire = "propriétaire" ;
laisser nouveau_propriétaire = propriétaire ;
console.log (nouveau_propriétaire);
L'exécution du code JavaScript ci-dessus fonctionne sans erreur, et si vous faites la même chose en Go ou Python, votre programme fonctionnera également sans erreur.
La troisième règle de propriété est qu'une fois qu'une variable est hors de la portée déclarée, la valeur est supprimée et la mémoire est désallouée.
// une variable dans une portée séparée
{
laisser exemple = Chaîne de caractères::from("Voici une nouvelle portée");
}
imprimer!("{}", Exemple)
Vous ne pouvez pas accéder au Exemple variable en dehors de son champ d'application; essayer de le faire provoquera la panique du compilateur.
Propriété des fonctions
Lorsque vous passez une valeur à une fonction en tant qu'argument, la fonction peut accéder à cette variable même si elle n'a pas été déclarée dans sa portée :
fnimprimante(évaluer: Chaîne de caractères) -> Chaîne de caractères {
revenir évaluer
}fnprincipale() {
laisser x = Chaîne de caractères::from("Imprime une valeur"); // x possède la valeur de chaîne
// la propriété est déplacée vers la fonction d'imprimante ici
imprimer!("{} La Résultat de l'impression X est qu'il -:", imprimante (x));
}
La fonction peut accéder à cette variable car Rust en transfère la propriété à la fonction au moment de la compilation.
Vous pourriez penser qu'il est toujours possible d'utiliser la variable plus tard dans sa portée d'origine :
fnimprimante(évaluer: Chaîne de caractères) -> Chaîne de caractères {
revenir évaluer
}fnprincipale() {
laisser x = Chaîne de caractères::from("Imprime une valeur");
imprimer!("{} La Résultat de l'impression x est qu'il -:", imprimante (x));
// Tentative d'utilisation de la variable après transfert de la propriété de sa valeur
imprimez !("{} ne devrait pas être accessible", x)
}
Mais si vous essayez ceci, le compilateur paniquera et refusera de produire un exécutable :
Rust donne la priorité à la réutilisation du code
La réutilisation du code est une pratique essentielle, mais pour pratiquer la réutilisation du code, vous devez comprendre les règles de propriété de Rust.
Rust est un langage de programmation très flexible. Il fournit des concepts tels que l'emprunt, le déplacement, la copie et la propriété du clonage pour une réutilisation variable.
