Pointeurs intelligents C++ : une analyse complète de leur cycle de vie

Cycle de vie du pointeur intelligent C++ : Création : Créez un pointeur intelligent lorsque la mémoire est allouée. Transfert de propriété : Transférer la propriété via une opération de déménagement. Libération : la mémoire est libérée lorsqu'un pointeur intelligent sort de la portée ou est explicitement libéré. Destruction d'objet : lorsque l'objet pointé est détruit, le pointeur intelligent devient un pointeur invalide.

Pointeur intelligent C++ : analyse complète de son cycle de vie

Introduction

Un pointeur intelligent est un pointeur spécial en C++ utilisé pour gérer la mémoire allouée dynamiquement. Contrairement aux pointeurs bruts, les pointeurs intelligents sont chargés de suivre l'état de la mémoire de l'objet vers lequel ils pointent et de libérer automatiquement cette mémoire lorsque l'objet n'est plus nécessaire. Cela permet d'éviter les erreurs de programmation courantes telles que les fuites de mémoire et les pointeurs suspendus.

Types

La bibliothèque standard C++ fournit quatre types principaux de pointeurs intelligents :

• unique_ptr8742468051c85b06f0a0af9e3e506b5c : Pointeur unique. Un seul unique_ptr peut pointer vers un objet à la fois.
• shared_ptr8742468051c85b06f0a0af9e3e506b5c : Pointeur vers la propriété partagée. Il peut y avoir plusieurs shared_ptr pointant vers le même objet.
• weak_ptr8742468051c85b06f0a0af9e3e506b5c : Pointeur de référence faible. faible_ptr n'empêche pas la destruction de l'objet et doit être utilisé avec shared_ptr.
• auto_ptr8742468051c85b06f0a0af9e3e506b5c : Abandonné. Supprimé en C++11.

Cycle de vie

1. Création

Des pointeurs intelligents peuvent être créés lorsque l'objet alloue de la mémoire, tout comme l'utilisation de pointeurs bruts :

auto ptr = std::make_unique<int>(42);

2. move) l'opération transfère la propriété :

auto ptr2 = std::move(ptr);  // ptr2 现在拥有对整数对象的唯一所有权

3. Release

Lorsqu'un pointeur intelligent quitte sa portée ou est explicitement libéré, il libère la mémoire qu'il possède :

{
    auto ptr = std::make_unique<int>(42);
    // ...
}  // ptr 在此处释放

4. Lorsque l'objet est détruit, le pointeur intelligent deviendra un pointeur invalide :

int* ptr = new int(42);
auto sptr = std::make_shared<int>(ptr);
delete ptr;  // ptr 被销毁
sptr->get();  // sptr 现在指向一个无效指针，因此 get() 会抛出异常

Cas pratique

Voici comment utiliser les pointeurs intelligents pour gérer les tableaux alloués dynamiquement :

// 原始指针版本
int* arr = new int[10];  // 分配数组

// ...

delete[] arr;  // 释放数组

// 智能指针版本
std::unique_ptr<int[]> arr = std::make_unique<int[]>(10);  // 分配数组

// ...

// arr 在离开范围时自动释放

La version du pointeur intelligent est plus sûre car elle empêche la mémoire fuites et pointeurs pendants.

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!