Smart Pointers

unique_ptr, shared_ptr

💡 Smart pointer ek self-cleaning robot hai — normal pointer (raw pointer) ek dumb tool hai jo tumhe khud yaad rakhna padta hai delete karna. Smart pointer khud track karta hai kab memory ki zaroorat khatam hui, aur automatically clean kar deta hai.

Manual new/delete ka sabse bada risk hai bhool jaana (memory leak) ya galat waqt par delete kar dena (dangling pointer). Modern C++ (C++11+) "smart pointers" deta hai (header <memory>) jo automatically memory manage karte hain — RAII principle use karke.

unique_ptr sabse common hai — ek resource ka sirf ek owner ho sakta hai (copy nahi ho sakta, sirf move ho sakta hai). shared_ptr multiple owners allow karta hai — internally reference counting rakhta hai, jab last owner destroy hota hai, tabhi memory free hoti hai.

#include <memory>
using namespace std;

class Resource {
  public:
    Resource() { cout << "Created" << endl; }
    ~Resource() { cout << "Destroyed" << endl; }
};

int main() {
  {
    unique_ptr<Resource> ptr1 = make_unique<Resource>();
    // koi delete ki zaroorat nahi — scope khatam hote hi automatic cleanup
  }  // yahi "Destroyed" print hoga

  shared_ptr<Resource> sp1 = make_shared<Resource>();
  {
    shared_ptr<Resource> sp2 = sp1;   // dono same resource share karte hain
    cout << sp1.use_count() << endl;  // 2 — do owners
  }  // sp2 destroy hua, lekin resource abhi zinda hai (sp1 abhi bhi hai)
  cout << sp1.use_count() << endl;   // 1
  return 0;
}

🧠

Smart pointer ek self-cleaning robot hai — normal pointer (raw pointer) ek dumb tool hai jo tumhe khud yaad rakhna padta hai delete karna. Smart pointer khud track karta hai kab memory ki zaroorat khatam hui, aur automatically clean kar deta hai.

1 / 2

⚡ Quick Recap

unique_ptr = single ownership, copy nahi ho sakta
shared_ptr = multiple ownership, reference counted
Scope khatam hote hi automatic cleanup — memory leaks se bachao

On this page (2 subtopics)

shared_ptr ka ek problem hai: agar do objects ek-doosre ko shared_ptr se refer karte hain (circular reference), reference count kabhi 0 nahi hota — memory leak, chahe koi bhi outside reference na ho. weak_ptr ek "non-owning" reference hai jo is problem ko solve karta hai — reference count mein count nahi hota.

class Node {
  public:
    shared_ptr<Node> next;
    weak_ptr<Node> prev;   // weak_ptr — cycle nahi banega
};

int main() {
  auto n1 = make_shared<Node>();
  auto n2 = make_shared<Node>();
  n1->next = n2;
  n2->prev = n1;   // weak_ptr — n1 ka reference count nahi badhta

  return 0;
}  // dono nodes properly clean ho jaate hain — koi leak nahi

⚠️Common Mistake: Agar dono directions shared_ptr hote (circular), na n1 na n2 kabhi destroy hote — reference count kabhi 0 nahi hota, chahe main() khatam ho jaaye. Ye ek subtle, common real-world smart pointer bug hai.

unique_ptr ko shared_ptr mein convert kar sakte ho (ownership transfer, move semantics se) — lekin shared_ptr ko wapas unique_ptr mein convert NAHI kar sakte (kyunki multiple owners ho sakte hain, "unique" guarantee todती hai).

unique_ptr<int> uptr = make_unique<int>(42);
shared_ptr<int> sptr = move(uptr);   // valid — ownership transfer

cout << *sptr << endl;   // 42
cout << (uptr == nullptr) << endl;  // 1 — uptr ab empty hai (moved-from)

💡Tip: Design principle: shuru karo unique_ptr se (zyada restrictive, zyada efficient) — agar baad mein pata chale multiple owners chahiye, tab shared_ptr mein migrate karo.

← Previous🏭 new & delete Next →🎁 RAII Pattern

Code10x

Smart Pointers

weak_ptr — Breaking Circular References

unique_ptr Ko shared_ptr Mein Convert Karna, Ulta Nahi