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

நீங்களே முயற்சி செய்து பாருங்கள்