Pointeurs intelligents de la rouille

Les pointeurs ne sont pas une nouvelle chose pour un programmeur. Ils sont une fonctionnalité qui vous permet d'utiliser des variables pour stocker une adresse en mémoire. L'adresse «pointe ensuite», d'où le pointeur, vers les données stockées à cet endroit.

Les pointeurs intelligents sont des pointeurs avec des capacités étendues, telles que les vérifications liées et la gestion automatique de la mémoire. Les pointeurs intelligents incluent également des métadonnées supplémentaires. Maintenant, le concept de pointeurs intelligents n'est pas nouveau, en particulier pour les programmeurs C ++.

Pour cet article, nous explorerons divers pointeurs intelligents tels que définis dans la Bibliothèque Standard Rust.

Points clés

Dans Rust, les pointeurs intelligents sont des structures de données cependant, contrairement aux pointeurs normaux, les pointeurs intelligents peuvent réellement posséder des données. Ils sont couramment mis en œuvre à l'aide de structures mais diffèrent des structures normales dans le sens où ils implémentent les traits Deref et Drop.

Il y a 5 pointeurs intelligents à connaître à Rust:

1. Boîte
2. Deref
3. Goutte
4. RC
5. Refcell

NOTE: Dans Rust fait référence au type de données.

Gardez à l'esprit que cela ne couvrira pas tous les pointeurs intelligents de cet article.

Boîte

Le pointeur intelligent de la boîte fournit un moyen de référencer les données stockées dans la mémoire du tas. Par défaut, Rust alloue tout sur la mémoire de la pile. En utilisant le pointeur intelligent de la boîte, nous pouvons accéder aux données sur le tas, sans aucune performance.

Le pointeur intelligent de la boîte obéit également aux règles de propriété et d'emprunt. Par conséquent, il a un seul propriétaire de données et ne peut avoir qu'une seule référence mutable et n'importe quel nombre de références immuables.

fn main ()
// Boîte
Laissez var = box :: new (100);
println!("Valeur: ", var)

Dans l'exemple ci-dessus, nous avons un pointeur intelligent en boîte qui stocke la valeur 5 dans le tas. Gardez à l'esprit que la boîte elle-même est stockée dans la pile.

Une fois le programme résilié, la boîte est traitée à partir de la mémoire.

Deref

Comme son nom l'indique, le pointeur intelligent Deref est utilisé pour permettre la manipulation de l'opération de déréférence. À l'aide du pointeur intelligent Deref, vous pouvez créer une structure qui peut fonctionner avec le pointeur intelligent et les références.

Un exemple de code est comme indiqué ci-dessous:

Utilisez Std :: Ops :: deref;
Custbox de structure
Données: T,

implorant Deref pour la custox
// Param de type générique
Type Target = T;
fn deref (& self) -> & t
&soi.données


fn main ()
Soit x = CustBox data: 100;
println!("Valeur: ", * (x.deref ()))

Goutte

Le pointeur Smart Drop est utilisé pour libérer la mémoire qui est allouée dans le tas. Le trait de goutte dans la rouille gère la mémoire lorsqu'une variable sort de la portée. Nous n'avons pas besoin d'appeler ce trait manuellement, car Rust fera cela pour nous. Cependant, nous pouvons l'implémenter pour les types personnalisés comme indiqué.

struct mystruct
x: i32,

Imp imprime pour mystruct
fn drop (& mut self)
println!("Dropping: ", self.X)


fn main ()
Selt _x = mystruct x: 100;
Selt _y = mystruct x: 200;

L'ensemble implémente le trait de dépôt pour le trait personnalisé. La sortie est comme indiqué:

Dossin: 200

Dossin: 100

Conclusion

Dans cet article, nous couvrons comment créer et travailler avec des pointeurs intelligents communs dans le langage de programmation Rust. Vous pouvez en savoir plus sur les pointeurs intelligents de Rust dans la ressource ci-dessous:

https: // doc.chanteur de la rouille.org / book / ch15-00-smart-pointeurs.html