Pointeurs intelligents dans Rust: comment fonctionnent-ils ?

La gestion de la mémoire est l'un des arguments de vente de Rust, d'autant plus que la sécurité n'est pas compromise. Le système de propriété de Rust permet au compilateur de garantir la sécurité du code et l'absence d'erreurs de mémoire telles que les pointeurs pendants et les fuites de mémoire.

Rust fournit également des pointeurs intelligents avec des métadonnées et des fonctionnalités supplémentaires au-delà des pointeurs traditionnels. Les pointeurs intelligents sont pratiques pour lutter contre les fuites de mémoire.

Que sont les pointeurs intelligents dans Rust?

Les pointeurs intelligents sont l'un des Les types de données de Rust qui étend les capacités des pointeurs réguliers en offrant des fonctionnalités supplémentaires telles que les opérateurs surchargés, les destructeurs et la gestion automatique de la mémoire.

Rust utilise des structures pour exécuter des pointeurs intelligents; ainsi, les pointeurs intelligents ont également des capacités de propriété.

Lorsque vous liez de la mémoire contenant des données allouées dynamiquement avec des pointeurs intelligents, ils sont automatiquement désalloués. Les pointeurs intelligents fournissent des fonctionnalités pour contrôler le Durée de vie de l'objet de Rust, ce qui les rend pratiques pour éviter les erreurs comme le déréférencement de pointeur nul et les fuites de mémoire qui sont courantes dans d'autres langages de bas niveau comme C et C++.

Avantages de l'utilisation de pointeurs intelligents

Voici quelques avantages de l'utilisation de pointeurs intelligents :

1. Gestion automatique de la mémoire: Les pointeurs intelligents fournissent une gestion automatique de la mémoire, y compris l'allocation et la désallocation, contrairement à la gestion manuelle de la mémoire avec des pointeurs réguliers.
2. Sécurité améliorée: Les pointeurs intelligents appliquent la sémantique de propriété, garantissant qu'un seul propriétaire peut accéder aux ressources à la fois, empêchant les traces de données et les bogues liés à la concurrence.
3. La flexibilité: Rust fournit plusieurs pointeurs intelligents, chacun avec son ensemble de sémantique de propriété pour écrire du code sécurisé de manière flexible.
4. La gestion des ressources: Vous pouvez utiliser des pointeurs intelligents pour gérer d'autres ressources comme les gestionnaires de fichiers et les sockets réseau en encapsulant les ressources dans un pointeur intelligent qui facilite la gestion de leur cycle de vie et s'assure qu'ils sont correctement fermés et libérés après utiliser.
5. Performance améliorée: Les pointeurs intelligents contribuent à améliorer les performances en réduisant la copie et les allocations de mémoire. La réduction de l'empreinte mémoire due à l'utilisation de pointeurs intelligents se traduit par des performances accrues.

Les pointeurs intelligents conviennent aux applications de taille moyenne à grande, en particulier dans les cas où la gestion de la mémoire est critique.

Types de pointeurs intelligents

Rust fournit plusieurs types de pointeurs intelligents, y compris Boîte, RC, RéfCell, et mutex.

1. Le pointeur intelligent de la boîte

Le Boîte Smart Pointer est le pointeur intelligent le plus simple et le plus courant de Rust. Le Boîte le pointeur intelligent aide à allouer des valeurs sur le tas et crée un pointeur encadré pour l'accessibilité.

Le Boîte Smart Pointer est pratique pour l'allocation de mémoire dynamique lorsque vous devez vous assurer que la mémoire est automatiquement désallouée lorsque les pointeurs sont hors de portée.

Voici comment vous pouvez déclarer et utiliser un Boîte aiguille:

fnprincipal(){
// nouvelle instance du pointeur intelligent de la boîte 
laisser x = Boîte::nouveau(5);
imprimez !(X)
}

Le Boîte type fait partie du prélude de Rust, vous n'aurez donc pas à importer le type, contrairement aux autres pointeurs intelligents.

Le X la variable est une Boîte pointeur pointant vers la valeur entière 5. Rust alloue la mémoire pour la valeur sur le tas et libère automatiquement lorsque la variable est hors de portée.

2. Le pointeur intelligent Rc

Le RC (Référence comptée) Le pointeur intelligent fournit des fonctionnalités pour créer des valeurs de propriété partagée. Le RC les pointeurs intelligents suivent le nombre de références à une valeur et libèrent la valeur lorsque la dernière référence est hors de portée.

Le RC Le pointeur intelligent est pratique lorsque vous devez partager la propriété d'une valeur d'accessibilité dans plusieurs parties de votre programme.

Pour déclarer un RC pointeur intelligent, vous allez importer le RC struct de la bibliothèque standard, déclarez une nouvelle RC pointeur avec le nouveau fonction, et clonez la variable de pointeur avec la cloner variable.

utiliser std:: rc:: Rc;
fnprincipal() {
// nouvelle instance du pointeur intelligent RC 
laisser x = Rc:: nouveau(5);
laisser y = Rc:: clone(&x);
imprimez !("x = {}, y = {}", x, y);
}

Le X variable est la RC variable de pointeur, et la y variable est un clone avec accès à la valeur en mémoire. Le nombre de références est de deux et la valeur est désallouée de la mémoire lorsque les variables sont hors de portée.

3. Le pointeur intelligent RefCell

Le RéfCell le pointeur intelligent fournit une mutabilité intérieure qui permet aux références immuables et mutables de coexister tant qu'il y a une référence mutable par temps donné.

Le RéfCell le pointeur intelligent est pratique lors de la mutation de valeurs appartenant à des références mutables.

Le Cellule de référence La fonction ne fait pas partie du prélude de Rust, vous devrez donc importer la structure de la bibliothèque standard pour utiliser le pointeur intelligent.

utiliser std:: cellule:: RefCell ;
fnprincipal(){
// nouvelle instance du pointeur intelligent Refcell 
laisser x = RefCell:: nouveau(5);
laisser y = x.emprunter();
laisser z = x.emprunter_mut();
imprimez !("y = {}", *y);
imprimez !("z = {}", *z);
} 

Le Cellule de référence le pointeur intelligent contient la valeur et le y variable est la référence immuable à la valeur. Le emprunter_mut La fonction crée une référence mutable de la valeur.

Le programme est sûr s'il n'y a qu'une seule référence mutable à la fois.

4. Le pointeur intelligent Mutex

Le mutex pointeur intelligent fournit des exclusions mutuelles. Le mutex Le pointeur intelligent est pratique pour synchroniser l'accès aux valeurs sur plusieurs threads dans des programmes simultanés.

Le mutex Le pointeur intelligent fournit une exclusion mutuelle pour garantir qu'un seul thread peut accéder à la valeur tout en empêchant les traces de données.

Vous devrez importer le mutex struct et créez une nouvelle instance avec la nouveau fonction à utiliser mutex Pointeur intelligent dans Rust.

utiliser std:: sync:: Mutex ;
fnprincipal() {
// nouvelle instance du pointeur mutex 
laisser compteur = Mutex:: nouveau(0);
 {
laissermuet num = compteur.lock().unwrap();
 *num += 1;
 }
imprimez !("Résultat: {}", *counter.lock().unwrap());
}

Le comptoir la variable est la nouvelle mutex exemple. Le principal fonction acquiert un verrou sur le mutex avec la serrure méthode de la mutex exemple. Le verrou permet de modifier en toute sécurité la valeur du compteur avant de libérer le verrou et d'imprimer la valeur.

Le mutex type garantit qu'un seul thread peut accéder aux ressources partagées (dans ce cas, le comptoir variable) et modifier sa valeur à la fois. L'exclusion mutuelle garantit que l'accès simultané aux ressources partagées est sérialisé pour éviter les traces de données et d'autres problèmes de simultanéité.

Le modèle de propriété de Rust garantit la sécurité de la mémoire

Les pointeurs intelligents sont l'une des approches de Rust en matière de sécurité et de flexibilité de la mémoire. Le modèle de propriété de Rust garantit que les programmes utilisent la mémoire en toute sécurité avec le vérificateur d'emprunt au moment de la compilation.

Le vérificateur d'emprunt est une caractéristique cruciale du modèle de propriété de Rust qui applique des règles strictes d'accessibilité et de modification de la mémoire.