Quels sont les types de pointeurs intelligents C++ et leurs différences ?

C++ fournit plusieurs types de pointeurs intelligents pour éviter les erreurs de mémoire : unique_ptr : est seul propriétaire de la ressource sous-jacente et libère automatiquement la ressource lorsqu'elle est hors de portée. shared_ptr : partage la propriété de la ressource sous-jacente et libère la ressource lorsque le dernier shared_ptr est détruit. faible_ptr : a une faible propriété de la ressource sous-jacente et n'empêche pas la libération de la ressource, mais peut vérifier en toute sécurité si la ressource existe. Le choix d'un type de pointeur intelligent dépend des exigences de propriété : unique_ptr pour une propriété unique, shared_ptr pour une propriété partagée et low_ptr pour la gestion des pointeurs en suspens.

Types de pointeurs intelligents et leurs différences en C++

En C++, un pointeur intelligent est un objet léger qui encapsule un pointeur brut et le libère automatiquement lorsque le pointeur d'origine sort de sa portée. Les pointeurs intelligents aident à éviter les erreurs telles que les fuites de mémoire et les pointeurs suspendus.

La bibliothèque standard C++ fournit plusieurs types de pointeurs intelligents, chacun avec son propre objectif et sa propre sémantique. Voici les principaux types de pointeurs intelligents :

• auto_ptr : Un pointeur intelligent qui libère automatiquement la ressource vers laquelle il pointe lorsqu'elle sort de sa portée. auto_ptr est obsolète en C++11 en raison de sa sémantique de transfert de propriété.
• unique_ptr : Un pointeur intelligent qui représente la propriété unique de la ressource sous-jacente. Une fois un unique_ptr créé, vous ne pouvez pas en créer un autre unique_ptr pointant vers la même ressource. Il s’agit du type de pointeur intelligent le plus basique.
• shared_ptr : Un pointeur intelligent qui représente la propriété partagée de la ressource sous-jacente. Plusieurs shared_ptr peuvent être créés pour pointer vers la même ressource. Lorsque le dernier shared_ptr est détruit, la ressource sous-jacente est libérée.
• weak_ptr : Un pointeur intelligent qui représente une faible propriété de la ressource sous-jacente. faible_ptr n'empêche pas la libération de la ressource sous-jacente, mais il est possible de vérifier en toute sécurité si la ressource sous-jacente existe toujours.

Exemple pratique

Considérez l'extrait de code suivant :

// unique_ptr 示例
{
    unique_ptr<string> str = make_unique<string>("Hello");
    cout << *str << endl; // 输出: Hello
} // str 超出作用域并释放 "Hello"

Dans cet exemple, unique_ptr 确保在 str libère la chaîne "Hello" lorsqu'elle sort de la portée.

Différences

Voici un résumé des principales différences entre les différents types de pointeurs intelligents :

Propriété transfert non pris en charge libère le pointeur brut Le plus sécuriséChoisir le bon pointeur intelligent Le choix du bon type de pointeur intelligent dépend des exigences spécifiques de l'application. Pour les scénarios de propriété unique, unique_ptr est préféré. Pour la propriété partagée, shared_ptr est le meilleur choix. faible_ptr est utile pour gérer les pointeurs pendants et implémenter des références circulaires.

Uniquement	Partagé	Faible
pris en charge	non pris en charge		portée
ne libère pas le pointeur brut (jusqu'à ce que la dernière référence ait disparu)	n'empêche pas le cru pointeur d'être libéré		Sécurité
Plus sécurisé	Le moins sécurisé

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!