Intelligenter Zeiger: schwacher_ptr (schwacher Referenz-Smart-Zeiger)

Der schwache Referenz-Smart-Pointer std::weak_ptr kann als Assistent von shared_ptr betrachtet werden, er verwaltet nicht den internen Zeiger von shared_ptr. std::weak_prt überlastet die Operatoren * und -> nicht, da es keine Zeiger teilt und keine Ressourcen betreiben kann, sodass seine Konstruktion den Referenzzähler nicht erhöht und seine Zerstörung den Referenzzähler nicht verringert. Seine Hauptfunktion ist als Ein Zuschauer überwacht die Existenz einer Ressource, die in einem shared_ptr verwaltet wird.

Initialisierung:

#include<iostream>
#include<memory>
using namespace std;

int main()
{
    shared_ptr<int> sp(new int);

    //weak_ptr<int> wp1; 构造一个空weak_ptr对象
    weak_ptrr<int> wp1;

    //weak_ptr<int> wp2(wp1);    通过一个空weak_ptr对象构造了另一个空weak_ptr对象
    weak_ptr<int> wp2(wp1);

    //weak_ptr<int> wp3(sp);通过一个shared_ptr对象构造了一个可用的weak_ptr实例对象

    weak_ptr<int> wp3(sp);

    //wp4 = sp;    通过一个shared_ptr对象构造了一个可用的weak_ptr实例对象（这是一个隐式类型转换）
    weak_ptr<int> wp4;
    wp4 = sp;

    //wp5 = wp3; 通过一个weak_ptr对象构造了一个可用的weak_ptr实例对象
    weak_ptr<int> wp5;
    wp5 = wp3;

    return 0;
}

use_count()

Der Referenzzähler der aktuell beobachteten Ressource kann durch Aufrufen der von der Klasse std::weak_ptr bereitgestellten Methode use_count() abgerufen werden

shared_ptr<int> sp(new int);

weak_ptr<int> wp1;
weak_ptr<int> wp2(wp1);
weak_ptr<int> wp3(sp);
weak_ptr<int> wp4;
wp4 = sp;
weak_ptr<int> wp5;
wp5 = wp3;

cout<<"use_count:"<<endl;
cout<<"wp1:"<<wp1.use_count()<<endl;
cout<<"wp2:"<<wp2.use_count()<<endl;
cout<<"wp3:"<<wp3.use_count()<<endl;
cout<<"wp4:"<<wp4.use_count()<<enld;


cout<<"wp5:"<<wp5.use_count<<endl;
return 0;

use_count:
wp1:0
wp2:0
wp3:1
wp4:1
wp5:1

Anhand der gedruckten Ergebnisse können wir erkennen, dass die schwachen Referenz-Smartpointer wp3, wp4 und wp5 zwar dieselbe Ressource überwachen, sich ihre Referenzanzahl jedoch nicht geändert hat, was ein weiterer Beweis dafür ist, dass schwach_ptr nur Ressourcen überwacht und keine Ressourcen verwaltet.

 Abgelaufen()

Bestimmen Sie, ob die beobachtete Ressource freigegeben wurde, indem Sie die von der Klasse std::weak_ptr bereitgestellte Expired()-Methode aufrufen

int main()
{
    shared_ptr<int> shared(new int(10));
    weak_ptr<int> weak(shared);
    cout<<"1.weak"<<(weak.expired()?"is":"is not")<<"expired"<<endl;

    shared.reset();
    cout<<"2.weak"<<(weak.expired()?"is":"is nor")<<"expired"<<endl;

    return 0;
}

//1.weak is not expired
//2.weak is expired

 schwach_ptr überwacht die von shared_ptr verwalteten Ressourcen. Wenn der gemeinsam genutzte Smart Pointer shared.reset(); aufruft, werden die verwalteten Ressourcen freigegeben, sodass das Ergebnis der Funktion schwach.expired() true zurückgibt, was darauf hinweist, dass die überwachten Ressourcen nicht mehr verfügbar sind.

 sperren()

Rufen Sie das shared_ptr-Objekt ab, das die überwachte Ressource verwaltet, indem Sie die von der Klasse std::weak_ptr bereitgestellte lock()-Methode aufrufen

int main()
{
    shared_ptr<int> sp1,sp2;
    weak_ptr<int> wp;
    
    sp1 = std::make_shared<int>(520);
    wp = sp1;
    sp2 = wp.lock();
    cout<<"use_count:"<<wp.use_count()<<endl;

    sp1.reset();
    cout<<"use_count:"<<wp.use_count()<<endl;

    sp1 = wp.lock();
    cout<<"use_count:"<<wp.use_count()<<endl;

    cout<<"*sp1:"<< *sp1<<endl;
    coutMM"*sp2:"<< *sp2<<endl;

    reutrn 0;
}


use_count:2
use_count:1
use_count:2
*sp1:520
*sp2:520

sp2 = wp.lock(); Rufen Sie die lock()-Methode auf, um ein gemeinsam genutztes Smart-Pointer-Objekt zum Verwalten der vom schwachen_ptr-Objekt überwachten Ressource zu erhalten. Verwenden Sie dieses Objekt, um sp2 zu initialisieren. Der Referenzzähler der überwachten Ressource beträgt 2. sp1. reset(); Der gemeinsam genutzte Smart Pointer sp1 wird zurückgesetzt, der Referenzzähler der vom schwachen_ptr-Objekt überwachten Ressource wird um 1 dekrementiert, sp1=wp.lock(); sp1 wird neu initialisiert und verwaltet die Ressource weiterhin Wird vom schwachen_ptr-Objekt überwacht, daher wird die Referenzanzahl um 1 erhöht, und die gemeinsam genutzten Smart-Pointer-Objekte sp1 und sp2 verwalten denselben Speicherblock, sodass die Ergebnisse im endgültigen gedruckten Speicher gleich sind und beide 520 betragen.