Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Explication des pointeurs intelligents

Smart Pointer est un outil en C++ utilisé pour gérer automatiquement la mémoire allouée dynamiquement.

Il s'agit d'une classe qui encapsule les fonctions des pointeurs bruts et peut gérer automatiquement l'allocation et la libération des ressources, aidant ainsi les programmeurs à éviter les erreurs courantes de gestion de la mémoire, telles que les fuites de mémoire, les pointeurs suspendus et d'autres problèmes.

Les pointeurs intelligents fonctionnent via le mécanisme RAII (Resource Acquisition Is Initialization), ce qui signifie que les pointeurs intelligents acquièrent des ressources lorsqu'elles sont construites et les libèrent lorsqu'elles sont détruites. Cela garantit que les ressources sont libérées correctement, même dans des circonstances anormales.

 

Problèmes résolus par des pointeurs intelligents

(1) Fuite de mémoire : la mémoire est libérée manuellement, mais elle peut être libérée automatiquement à l'aide de pointeurs intelligents.

(2) Propagation et publication de pointeurs de propriété partagée, tels que des problèmes de destruction lorsque plusieurs threads utilisent le même objet.

 

Plusieurs types de pointeurs intelligents

La bibliothèque standard C++ fournit plusieurs types de pointeurs intelligents, notamment :

1. std::unique_ptr：

   • modèle de propriété exclusive, c'est-à-dire ununique_ptrUne instance est propriétaire exclusive de l’objet vers lequel elle pointe.
   • quandunique_ptrLorsqu'il sort de la portée ou est explicitement réinitialisé, il appelle automatiquement le destructeur et libère l'objet géré.
   • La copie n'est pas prise en charge, mais le déplacement est possible.

2. std::shared_ptr：

   • Modèle de propriété partagée, permettant à plusieursshared_ptrLes instances partagent la propriété du même objet.
   • Utiliser le comptage de références pour suivre les références au même objetshared_ptrquantité.
   • quand le derniershared_ptrLorsqu'une instance sort de la portée ou est réinitialisée, le nombre de références est réduit à zéro, le destructeur de l'objet est appelé et l'objet est libéré.

3. std::weak_ptr：

   • utilisé pour résoudreshared_ptrproblème de référence circulaire.
   • Sans incrémenter le décompte de référence, il peut être observé parshared_ptrobjets gérés, mais ne participe pas à la gestion de son cycle de vie.
   • Quand il n'y a passhared_ptrLorsqu'une instance pointe vers un objet,weak_ptrPeut détecter que l'objet a été détruit.

La conception et l'utilisation de pointeurs intelligents simplifient grandement la gestion de la mémoire en C++ et améliorent la robustesse et la sécurité du programme. Dans la programmation C++ moderne, il est fortement recommandé d'utiliser des pointeurs intelligents au lieu de pointeurs bruts pour améliorer la qualité et la maintenabilité du code.

 

Exemple de pointeur intelligent

Les pointeurs intelligents sont utilisés en C++ comme moyen de gérer automatiquement la mémoire allouée dynamiquement afin d'éviter les fuites de mémoire et d'autres problèmes liés à la gestion des ressources.

std::unique_ptrExemple

std::unique_ptrest un pointeur intelligent à propriété exclusive, qui garantit qu'il n'y a qu'un seulstd::unique_ptr Une instance contrôle une ressource donnée.quandstd::unique_ptrLorsqu'il sort de sa portée ou est réinitialisé, les ressources qu'il possède seront automatiquement libérées.

#include <memory>
 
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor called.n"; }
    ~MyClass() { std::cout << "MyClass destructor called.n"; }
    void doSomething() { std::cout << "Doing something...n"; }
};
 
int main() {
    // 创建一个unique_ptr来管理MyClass的实例
    std::unique_ptr<MyClass> uptr(new MyClass());
 
    // 调用doSomething方法
    uptr->doSomething();
 
    // unique_ptr会在离开作用域时自动调用MyClass的析构函数
    return 0;
}

std::shared_ptrExemple

std::shared_ptrest un pointeur intelligent de propriété partagée qui permet à plusieursstd::shared_ptrLes instances partagent la propriété de la même ressource.std::shared_ptrUtilisez un nombre de références pour suivre le nombre de pointeurs intelligents pointant vers la même ressource. Lorsque le nombre de références atteint 0, la ressource est libérée.

#include <memory>
 
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor called.n"; }
    ~MyClass() { std::cout << "MyClass destructor called.n"; }
    void doSomething() { std::cout << "Doing something...n"; }
};
 
int main() {
    // 创建一个shared_ptr来管理MyClass的实例
    std::shared_ptr<MyClass> sptr(new MyClass());
    
    // 创建第二个shared_ptr，共享同一个MyClass实例
    std::shared_ptr<MyClass> sptr2 = sptr;
 
    // 调用doSomething方法
    sptr->doSomething();
 
    // 当所有shared_ptr实例都超出作用域时，MyClass的析构函数才会被调用
    return 0;
}

 

Précautions

Utiliséstd::shared_ptr Ce faisant, veillez à éviter les situations de référence circulaire, qui empêcheraient le nombre de références de tomber à 0, entraînant des fuites de ressources.Dans le cas de références circulaires, vous pouvez utiliserstd::weak_ptrpour briser le cycle,std::weak_ptrN'incrémente pas le nombre de références, conserve uniquement lestd::shared_ptrGérer les références faibles aux ressources.

Ces exemples montrent comment utiliser des pointeurs intelligents pour gérer la mémoire allouée dynamiquement afin de garantir que les ressources sont correctement libérées au moment approprié, évitant ainsi les erreurs courantes pouvant survenir lors de la gestion manuelle de la mémoire.

 

Autres exemples

https://www.cnblogs.com/god-of-death/p/17962676

https://zhuanlan.zhihu.com/p/678722914