std::weak_ptr

std::shared_ptr చాలా ఉపయోగకరంగా ఉన్నప్పటికీ, భాగస్వామ్య యాజమాన్యంపై మాత్రమే ఆధారపడటం వృత్తాకార సూచన (లేదా చక్రీయ ఆధారపడటం) అని పిలువబడే సమస్యకు దారితీయవచ్చు.

రెండు లేదా అంతకంటే ఎక్కువ ఆబ్జెక్ట్‌లు ఒక్కొక్కటి shared_ptrని కలిగి ఉన్నట్లయితే, ఒక క్లోజ్డ్ లూప్ సృష్టించబడుతుంది. ఈ పరిస్థితిలో, ఏ వస్తువు యొక్క సూచన గణన సున్నాకి చేరుకోదు, డీలాకేషన్‌ను నివారిస్తుంది మరియు మెమరీ లీక్‌కు కారణమవుతుంది.

std::weak_ptr అంటే ఏమిటి

యాజమాన్య చక్రాలను విచ్ఛిన్నం చేయడానికి, ప్రామాణిక లైబ్రరీ **std::weak_ptr**ని అందిస్తుంది. ఇది shared_ptr ద్వారా నిర్వహించబడే వస్తువును గమనించే స్మార్ట్ పాయింటర్, కానీ ప్రస్తావన గణనను పెంచకుండా.

ఇది నేరుగా వనరును కలిగి ఉండదు, కాబట్టి ఇది దాని విధ్వంసం నిరోధించదు.

#include <memory>

std::shared_ptr<int> shared = std::make_shared<int>(42);
std::weak_ptr<int> weak = shared; // Does not increment reference count!

వనరులను ధృవీకరించడం మరియు యాక్సెస్ చేయడం

ఒక weak_ptr వనరుని కలిగి లేనందున, వనరు ఏ సమయంలోనైనా డీలాకేట్ చేయబడవచ్చు (అన్ని అనుబంధిత shared_ptr సందర్భాలు పరిధిని దాటి పోయినప్పుడు).

గమనించిన వనరును ఉపయోగించడానికి, మనం తప్పక:

1. expired() ఉపయోగించి ఇది ఇప్పటికీ చెల్లుబాటులో ఉందో లేదో తనిఖీ చేయండి.
2. lock() పద్ధతిని ఉపయోగించి weak_ptrని shared_ptrగా తాత్కాలికంగా మార్చండి. వనరు ఇప్పటికీ సక్రియంగా ఉంటే, lock() చెల్లుబాటు అయ్యే shared_ptrని అందిస్తుంది, లేకుంటే అది శూన్య పాయింటర్ (nullptr)ని అందిస్తుంది.

if (!weak.expired()) {
    // lock() creates a temporary shared_ptr to ensure safe access
    if (std::shared_ptr<int> sharedAccess = weak.lock()) {
        std::cout << *sharedAccess << std::endl;
    }
} else {
    std::cout << "Resource deallocated!" << std::endl;
}

మీరే ప్రయత్నించండి