Technologieaustausch

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

Intelligente Zeiger erklärt

Smart Pointer ist ein Tool in C++, mit dem dynamisch zugewiesener Speicher automatisch verwaltet wird.

Dabei handelt es sich um eine Klasse, die die Funktionen von Rohzeigern kapselt und die Zuweisung und Freigabe von Ressourcen automatisch handhaben kann. Dadurch können Programmierer häufig auftretende Speicherverwaltungsfehler wie Speicherlecks, baumelnde Zeiger und andere Probleme vermeiden.

Intelligente Zeiger funktionieren über den RAII-Mechanismus (Resource Acquisition Is Initialization), was bedeutet, dass intelligente Zeiger Ressourcen erwerben, wenn sie erstellt werden, und Ressourcen freigeben, wenn sie zerstört werden. Dadurch wird sichergestellt, dass Ressourcen auch unter außergewöhnlichen Umständen korrekt freigegeben werden.

 

Durch intelligente Zeiger gelöste Probleme

(1) Speicherverlust: Der Speicher wird manuell freigegeben, kann jedoch mithilfe intelligenter Zeiger automatisch freigegeben werden.

(2) Weitergabe und Freigabe gemeinsamer Eigentumszeiger, z. B. Zerstörungsprobleme, wenn mehrere Threads dasselbe Objekt verwenden.

 

Verschiedene Arten von intelligenten Zeigern

Die C++-Standardbibliothek bietet verschiedene Arten von Smart Pointern, darunter:

1. std::unique_ptr：

   • exklusives Eigentumsmodell, d. h. aunique_ptrEine Instanz hat das ausschließliche Eigentum an dem Objekt, auf das sie verweist.
   • Wannunique_ptrWenn es den Gültigkeitsbereich verlässt oder explizit zurückgesetzt wird, ruft es automatisch den Destruktor auf und gibt das verwaltete Objekt frei.
   • Das Kopieren wird nicht unterstützt, das Verschieben ist jedoch möglich.

2. std::shared_ptr：

   • Shared-Ownership-Modell, das mehrere ermöglichtshared_ptrInstanzen teilen sich den Besitz desselben Objekts.
   • Verwenden Sie die Referenzzählung, um Referenzen auf dasselbe Objekt zu verfolgenshared_ptrMenge.
   • wann das letzteshared_ptrWenn eine Instanz den Gültigkeitsbereich verlässt oder zurückgesetzt wird, wird der Referenzzähler auf Null reduziert, der Destruktor des Objekts aufgerufen und das Objekt freigegeben.

3. std::weak_ptr：

   • zur Lösung verwendetshared_ptrZirkelverweisproblem.
   • Ohne den Referenzzähler zu erhöhen, kann er beobachtet werdenshared_ptrverwaltete Objekte, beteiligt sich jedoch nicht an deren Lebenszyklusverwaltung.
   • Wenn es keine gibtshared_ptrWenn eine Instanz auf ein Objekt zeigt,weak_ptrKann erkennen, dass das Objekt zerstört wurde.

Der Entwurf und die Verwendung intelligenter Zeiger vereinfacht die Speicherverwaltung in C++ erheblich und verbessert die Robustheit und Sicherheit des Programms. In der modernen C++-Programmierung wird dringend empfohlen, intelligente Zeiger anstelle von Rohzeigern zu verwenden, um die Qualität und Wartbarkeit des Codes zu verbessern.

 

Beispiel für einen intelligenten Zeiger

Intelligente Zeiger werden in C++ als Mittel zur automatischen Verwaltung von dynamisch zugewiesenem Speicher verwendet, um Speicherlecks und andere Probleme im Zusammenhang mit der Ressourcenverwaltung zu verhindern.

std::unique_ptrBeispiel

std::unique_ptrist ein intelligenter Zeiger mit exklusivem Besitz, der sicherstellt, dass es nur einen gibtstd::unique_ptr Eine Instanz hat die Kontrolle über eine bestimmte Ressource.Wannstd::unique_ptrWenn es den Gültigkeitsbereich verlässt oder zurückgesetzt wird, werden die Ressourcen, die es besitzt, automatisch freigegeben.

#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_ptrBeispiel

std::shared_ptrist ein intelligenter Zeiger mit gemeinsamem Besitz, der mehrere zuläsststd::shared_ptrInstanzen teilen sich den Besitz derselben Ressource.std::shared_ptrVerwenden Sie einen Referenzzähler, um zu verfolgen, wie viele intelligente Zeiger auf dieselbe Ressource verweisen. Wenn der Referenzzähler 0 erreicht, wird die Ressource freigegeben.

#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;
}

 

Vorsichtsmaßnahmen

In Benutzungstd::shared_ptr Achten Sie dabei darauf, Situationen mit Zirkelverweisen zu vermeiden, die dazu führen, dass der Referenzzähler nie auf 0 sinkt, was zu Ressourcenlecks führt.Bei Zirkelverweisen können Sie verwendenstd::weak_ptrden Kreislauf durchbrechen,std::weak_ptrErhöht den Referenzzähler nicht, sondern speichert nur denstd::shared_ptrVerwalten Sie schwache Verweise auf Ressourcen.

Diese Beispiele zeigen, wie intelligente Zeiger zum Verwalten von dynamisch zugewiesenem Speicher verwendet werden, um sicherzustellen, dass Ressourcen zum richtigen Zeitpunkt ordnungsgemäß freigegeben werden, und um häufige Fehler zu vermeiden, die bei der manuellen Speicherverwaltung auftreten können.

 

Andere Beispiele

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

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