Pointeurs intelligents C++ : L'évolution des pointeurs, une bonne solution aux problèmes de mémoire

Les pointeurs intelligents sont des outils en C++ qui résolvent les problèmes de gestion de la mémoire en gérant automatiquement la libération de mémoire. Les types de pointeurs intelligents couramment utilisés sont : unique_ptr : propriété exclusive, libérant l'objet pointé lorsqu'il est détruit. shared_ptr : propriété partagée, le comptage de références suit le nombre de pointeurs et l'objet est libéré lorsque le dernier pointeur est détruit. faible_ptr : une référence faible n'augmente pas le cycle de vie de l'objet et ne peut être utilisée qu'en combinaison avec shared_ptr.

Pointeurs intelligents C++ : L'évolution des pointeurs, une bonne solution aux problèmes de mémoire

Les pointeurs intelligents sont des outils puissants en C++ qui aident à résoudre des problèmes tels que les fuites de mémoire et les pointeurs sauvages en gérant automatiquement la libération de mémoire. Comparés aux pointeurs traditionnels, les pointeurs intelligents sont plus sûrs et plus efficaces, permettant aux programmeurs de se concentrer sur l'écriture de la logique métier sans se soucier des détails fastidieux de la gestion de la mémoire.

Plusieurs pointeurs intelligents communs

unique_ptr

• propriété exclusive, pointant vers un seul objet.
• Lorsque unique_ptr est détruit, l'objet vers lequel il pointe sera également détruit.

shared_ptr

• Propriété partagée, permettant à plusieurs objets de pointer vers le même bloc de mémoire.
• Le nombre de références suit le nombre de pointeurs. Lorsque le dernier shared_ptr est détruit, l'objet pointé sera détruit.

weak_ptr

• Une référence faible n'augmentera pas le cycle de vie de l'objet pointu.
• Ne peut être utilisé qu'en combinaison avec shared_ptr. Lorsque le dernier shared_ptr est détruit, le faible_ptr sera défini comme invalide.

Cas pratique

Supposons que nous ayons une classe Person, qui représente une personne. Notre objectif est de créer un vecteur qui stocke les objets Person et de garantir que la mémoire est automatiquement libérée lorsque le vecteur sort de la portée. Person 类，它表示一个人。我们的目标是创建一个存储 Person 对象的向量，并确保当向量超出了作用域时，内存会被自动释放。

#include <iostream>
#include <vector>
#include <memory>

class Person {
public:
    Person(const std::string& name) : name(name) {}
    ~Person() { std::cout << "Destructor called for " << name << std::endl; }

private:
    std::string name;
};

int main() {
    std::vector<std::shared_ptr<Person>> people;

    // 添加几个 Person 对象
    people.push_back(std::make_shared<Person>("John"));
    people.push_back(std::make_shared<Person>("Mary"));
    people.push_back(std::make_shared<Person>("Bob"));

    // 遍历并打印名称
    for (const auto& person : people) {
        std::cout << person->name << std::endl;
    }

    return 0;
}

输出：

John
Mary
Bob
Destructor called for John
Destructor called for Mary
Destructor called for Bob

在示例中，我们使用 std::shared_ptr8abf60ac54173a2785e603c7a1f95b4e 来存储 Person 对象的指针。当 people 向量超出作用域销毁时，智能指针也会随之销毁。这将自动释放 Personrrreee

Sortie : 🎜rrreee🎜Dans l'exemple, nous utilisons std::shared_ptr8abf60ac54173a2785e603c7a1f95b4e pour stocker le pointeur de l'objet Person. Lorsque le vecteur people est détruit hors de portée, le pointeur intelligent est également détruit. Cela libérera automatiquement la mémoire occupée par l'objet Person et évitera les fuites de mémoire. 🎜

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!