Comment travailler avec la propriété de Rust

Dans cet article, nous explorerons la propriété de la rouille et comment cela fonctionne. L'approche de propriété et d'emprunt est une construction relativement nouvelle et trébuche. Dans ce guide, nous essaierons de démystifier le fonctionnement de la propriété.

Qu'est-ce que la propriété?

Traditionnellement, il existe deux façons fondamentales de gérer les souvenirs. Le premier est les collectionneurs d'ordures; Il est principalement utilisé dans les langages de haut niveau qui abstraitent le concept de gestion de la mémoire du programmeur.

La seconde est la gestion de la mémoire «manuelle», où le programmeur définit explicitement l'utilisation de la mémoire. Bien qu'il fournisse le contrôle, il laisse beaucoup de place pour vous tirer dans le pied.

Rust adopte une approche alternative appelée propriété et emprunt. La propriété est une nouvelle «construction» qui définit une valeur a son propriétaire.

Voici les règles de propriété de la rouille:

1. Toute valeur définie dans un programme de rouille a un propriétaire.
2. Une valeur peut avoir un propriétaire à la fois.
3. Une valeur ne peut vivre que tant que son propriétaire est vivant. Ce qui signifie que le propriétaire n'a pas été abandonné.

Pour mieux comprendre la propriété de la rouille, discutons quelques concepts et exemples.

Portée

Nous pouvons définir la portée comme une plage sous laquelle une valeur spécifiée vit. La portée joue un rôle important dans la propriété et l'emprunt.

Chaque variable est liée par sa portée. Dans ce cas, une portée se réfère à un bloc tel qu'il est enfermé par une paire de bretelles bouclées.

Considérez l'exemple suivant Programme:

fn main ()
// défini dans la portée de la fonction principale
Soit Long_Life = 100;

// défini dans un bloc intérieur (nouvelle portée)
LET Short_Life = 10;
println!("Scope intérieure: ", short_life);

// short_life n'existe pas dans cette portée
println!("Extérieur Scope: ", short_life);
println!("Longue durée de vie: ", long_life);

fn new_func ()
println!("Fonction Scope: ", long_life);

Dans l'exemple précédent, nous avons deux fonctions: la fonction principale et la fonction new_func.

À l'intérieur de la fonction principale, nous déclarons une nouvelle variable appelée long_life. Nous créons également une nouvelle portée et déclarons une nouvelle variable appelée short_life.

Si vous exécutez le code précédent, le compilateur de rouille vous dira que les variables, short_life et long_life, n'existent pas dans cette portée.

En effet, la variable short_life est déclarée dans une nouvelle portée. Lorsque cette portée se termine, la variable est abandonnée. Cela signifie que la variable short_life n'existe pas en dehors des accolades bouclées.

Le même cas s'applique à la variable long_life. Il n'est accessible que dans la fonction principale. Tenter d'y accéder dans une autre fonction n'est pas autorisé.

Ombrage

L'observation variable est un cas typique. Il se réfère à une fonctionnalité où la première déclaration variable est «écrasée» ou ombragée par un autre.

Prenez l'exemple de code suivant:

fn main ()
Soit Var1 = 10;
println!("Avant Shadow: ", var1);
// après l'ombre
Soit var1 = 100;
println!("After Shadow: ", var1);

Ici, nous avons une variable appelée var1 définie sur 10. Ensuite, nous l'avons l'ombre en déclarant la variable avec le même nom et la définissons sur une nouvelle valeur.

Cela devrait imprimer:

Remarque: ne confondez pas l'observation avec la mutabilité. Vérifiez notre tutoriel sur la mutabilité de la rouille pour en savoir plus.

Transfert de propriété

Rust nous permet de transférer la propriété de la valeur à l'aide d'opérations de copie ou de déplacement. Prenez l'exemple de code suivant:

fn main ()
Soit Var1 = 10;
Soit var2 = var1;
println!("var1: ", var1);
println!("var2: ", var2);

L'exemple précédent déclare une variable, var1, et lui attribue la valeur 10. Nous déclarons également une nouvelle variable, var2, et l'avons attribuée à VAR1.

Lorsque cela se produit, Rust créera une nouvelle copie de la valeur et l'attribuera à Var2. Cela signifie que les deux variables ne partagent pas la valeur, et chacune occupe son propre espace de mémoire.

Que se passe-t-il lorsque nous essayons d'effectuer l'opération précédente sur une valeur avec une taille de mémoire non déterministe?

Prenez un type de chaîne, par exemple. Puisqu'il peut se développer ou rétrécir, il n'y a pas de taille de mémoire prédéterminée. Par conséquent, il n'implémente pas le trait de copie:

Soit str1 = string :: from ("hi");
Soit str2 = str1;
println!("str1: ", str1);
println!("str1: ", str2);

Exécuter le même opération oblige le compilateur de rouille à déplacer la valeur de STR1 vers STR2. Puisqu'une valeur ne peut avoir qu'un seul propriétaire à la fois, la variable STR1 n'est plus valide. Cela amènera le compilateur à renvoyer une erreur si nous essayons d'y accéder:

Conclusion

Une des raisons pour lesquelles Rustaceans adore le langage de programmation Rust est la propriété. C'est une nouvelle fonctionnalité qui offre plus de flexibilité et de sécurité en même temps. Comprendre comment cela fonctionne peut être bénéfique pour créer des applications rapides et efficaces. De plus, les règles de propriété et les concepts ont été discutés. Nous espérons que vous avez trouvé cet article utile. Vérifiez les autres articles sur les indices Linux pour plus de conseils et d'informations.