std::unique_ptr మరియు std::shared_ptr

క్లాసికల్ C++లో, new మరియు delete ఆపరేటర్‌లను ఉపయోగించి మాన్యువల్ మెమరీ నిర్వహణ అనేది మెమరీ లీక్‌లు (వనరులు ఎప్పుడూ విడుదల చేయబడలేదు) లేదా డాంగ్లింగ్ పాయింటర్‌లు (డీలోకేట్ చేసిన మెమరీని సూచించే పాయింటర్లు) వంటి బగ్‌ల యొక్క సాధారణ మూలం.

ఆధునిక C++ <memory> హెడర్‌లో నిర్వచించబడిన స్మార్ట్ పాయింటర్‌లను పరిచయం చేసింది. వారు RAII (రిసోర్స్ అక్విజిషన్ ఈజ్ ఇనిషియలైజేషన్)ని ఉపయోగించి హీప్-కేటాయింపబడిన మెమరీ జీవితచక్రాన్ని స్వయంచాలకంగా నిర్వహిస్తారు, స్మార్ట్ పాయింటర్ స్కోప్ లేకుండా పోయినప్పుడు వనరును డీలాకేట్ చేస్తారు.

std::unique_ptr

std::unique_ptr వనరు యొక్క ప్రత్యేక యాజమాన్యం భావనను అమలు చేస్తుంది. ఇది కాపీ చేయబడదు, కేవలం తరలించబడింది (std::move ద్వారా).

#include <memory>

// Recommended creation using std::make_unique (C++14)
std::unique_ptr<int> p1 = std::make_unique<int>(42);

// Accessing the resource like a normal pointer
std::cout << *p1 << std::endl;

// std::unique_ptr<int> p2 = p1; // COMPILER ERROR: copy not allowed!
std::unique_ptr<int> p2 = std::move(p1); // Allowed: p1 transfers ownership to p2

std::shared_ptr

std::shared_ptr భాగస్వామ్య యాజమాన్యం భావనను అమలు చేస్తుంది. బహుళ స్మార్ట్ పాయింటర్‌లు ఒకే వనరును సూచించగలవు. తరగతి అంతర్గతంగా సూచన గణనను నిర్వహిస్తుంది: చివరి క్రియాశీల shared_ptr నాశనం చేయబడినప్పుడు లేదా రీసెట్ చేయబడినప్పుడు మాత్రమే మెమరీ ఖాళీ చేయబడుతుంది.

#include <memory>

std::shared_ptr<int> s1 = std::make_shared<int>(100);
std::shared_ptr<int> s2 = s1; // Allowed: increments the reference count

std::cout << s1.use_count() << std::endl; // Prints 2 (s1 and s2 share the resource)

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