Smart pointers — unique_ptr (sole ownership), shared_ptr (shared ownership, ref count), weak_ptr (break cycles)

5.2.12 · Coding › C++ Programming

1. Problem jise hum solve kar rahe hain

Worked example Raw pointers kyun leak karte hain

void f() {
    int* p = new int(42);
    if (something()) return;   // ⚠️ leak! hum kabhi p delete nahi karte
    delete p;
}

Yeh step kyun? Har new ke saath ek matching delete chahiye. Dono ke beech koi bhi early return, throw, ya break delete ko skip kar deta hai. Smart pointers us delete ko destructor mein le jaate hain, jo hamesha scope exit par run hota hai.

2. `unique_ptr` — akela ownership

Worked example

unique_ptr ka use karna

#include <memory>
auto p = std::make_unique<int>(42);   // preferred: exception-safe
std::cout << *p;                       // 42  — pointer ki tarah dereference karo
 
auto q = std::move(p);   // ownership moves p -> q
// ab p == nullptr hai, q int ka owner hai
 
if (!p) std::cout << "p is empty";     // true

make_unique kyun? Yeh new karta hai aur ek hi call mein unique_ptr construct karta hai → koi raw new floating around nahi, aur yeh exception-safe hai. std::move kyun? Copy forbidden hai; move rvalue mein cast karta hai to move-constructor run hota hai aur pointer transfer karta hai, source ko null karte hue.

Worked example Factory se ownership return karna

std::unique_ptr<Widget> makeWidget() {
    return std::make_unique<Widget>();   // automatically move out ho jaata hai
}

Yeh step kyun? Value se return karne par unique_ptr move out ho jaata hai — factories ke liye perfect; caller sole owner ban jaata hai.

3. `shared_ptr` — reference count ke zariye shared ownership

Worked example Reference counting in action

auto a = std::make_shared<int>(7);   // strong = 1
{
    auto b = a;                       // copy → strong = 2
    std::cout << a.use_count();       // 2
}                                     // b marta hai → strong = 1
std::cout << a.use_count();           // 1
// a scope ke end par marta hai → strong = 0 → int deleted

make_shared kyun? Yeh object aur control block ko ek memory block mein allocate karta hai → faster, ek allocation, better cache locality (shared_ptr<int>(new int(7)) ke comparison mein jo do allocations karta hai).

4. `weak_ptr` — reference cycles tod do

Figure — Smart pointers — unique_ptr (sole ownership), shared_ptr (shared ownership, ref count), weak_ptr (break cycles)

Worked example Parent↔child cycle todna

struct Node {
    std::shared_ptr<Node> next;     // next node ko own karta hai
    std::weak_ptr<Node>   prev;     // ⬅ weak: observe karta hai, own NAHI karta
};
 
auto n1 = std::make_shared<Node>();
auto n2 = std::make_shared<Node>();
n1->next = n2;          // n2 strong = 2
n2->prev = n1;          // n1 strong = 1 (weak count nahi hota!)
// jab n1, n2 scope se bahar jaate hain → dono free. Koi leak nahi. ✅

prev ko weak kyun banate hain? Yeh express karta hai "main refer karta hoon wapas lekin apne parent ka owner nahi hoon." Isse ek direction non-counting rehta hai, to cycle ka strong count 0 tak pahunch sakta hai.

Worked example

weak_ptr ko safely use karna

std::weak_ptr<int> w = somePtr;
if (auto s = w.lock()) {     // shared_ptr lene ki koshish karo
    std::cout << *s;          // safe: object ab bhi alive hai
} else {
    std::cout << "expired";   // object already deleted
}

lock() kyun, raw deref kyun nahi? Check karne aur use karne ke beech, object kisi aur owner ke zariye delete ho sakta hai. lock() atomically ya to object ko pin karta hai (strong++) ya batata hai ki gone ho gaya — koi dangling access nahi.

5. Sahi wala choose karna (80/20)

Common mistake Common errors ko steel-man karna

(1) "Ek hi raw pointer se do shared_ptrs count share karte hain." Kyun sahi lagta hai: woh ek hi object ko point karte hain, surely coordinate karenge. Reality: shared_ptr<T> a(raw); shared_ptr<T> b(raw); do alag control blocks create karta hai → dono sochte hain ki woh sole owner hain → double-free. Fix: ek shared_ptr banao aur copy karo, ya make_shared use karo.

(2) "weak_ptr mujhe directly *w karne deta hai." Kyun sahi lagta hai: yeh object ko point karta hai. Reality: weak_ptr mein * / -> nahi hai. Fix: w.lock() call karo aur result check karo.

(3) "unique_ptr ko copy karna simply kaam karna chahiye." Kyun sahi lagta hai: doosre pointers theek se copy hote hain. Reality: copy deleted hai (double-free ho jaata). Fix: ownership transfer karne ke liye std::move use karo.

(4) "make_shared aur shared_ptr<T>(new T) identical hain." Reality: make_shared = ek allocation (object + control block saath); doosra = do allocations aur kuch call patterns mein exception-safe nahi. Fix: make_shared/make_unique prefer karo.

Recall Feynman: ek 12-saal ke bachche ko explain karo

Socho ek library book. unique_ptr ek aisi book hai jo sirf tum rakh sakte ho — jab tum jaate ho, book automatically return ho jaati hai. Tum ise kisi dost ko de sakte ho (move), lekin phir tumhare paas nahi rahti. shared_ptr ek popular book hai jis par ek chhoti tally sheet hai: jo bhi borrow karta hai ek tick lagaata hai, jo bhi return karta hai ek tick hatata hai. Jab ticks zero ho jaati hain, book shelf par wapas jaati hai (deleted). weak_ptr woh insaan hai jisne sirf kahan hai book likh liya, lekin actually borrow nahi kiya — woh koi tick nahi lagate. Padhne se pehle unhe check karna hota hai "kya book abhi bhi yahan hai?" (lock()). Weak wala insaan do doston ko accident mein ek book forever rokne se bachata hai sirf ek doosre ko point karke (cycle).

Flashcards

unique_ptr ownership ke baare mein kya guarantee deta hai?

Exactly ek owner; yeh non-copyable hai, sirf movable hai (ownership transfer hoti hai, kabhi duplicate nahi).

unique_ptr non-copyable kyun hai?

Do copies dono ek hi object ko delete karengi → double-free; copy ctor =deleted hai, isliye std::move use karna padta hai.

make_unique / make_shared tumhe new ke comparison mein kya dete hain?

Koi raw new nahi, exception safety; make_shared object + control block ke liye single allocation bhi karta hai.

shared_ptr kya store karta hai?

Object ka pointer plus control block ka pointer jo strong count, weak count, aur deleter rakhta hai.

shared_ptr-managed object kab delete hota hai?

Jab strong (owner) count 0 tak pahunche; control block tab free hota hai jab strong0 AND weak0.

shared_ptr copy karne par use_count() ka kya hota hai?

1 badhta hai; jab copy destroy ya reset hoti hai to 1 ghatta hai.

weak_ptr kya problem solve karta hai?

Reference cycles — do shared_ptrs jo ek doosre ko point karte hain kabhi count 0 tak nahi pahunchate aur leak karte hain; weak_ptr strong count badhaye bagair observe karta hai.

weak_ptr ke peeche object ko safely kaise access karte hain?

lock() call karo; yeh ek shared_ptr return karta hai agar alive ho, ya empty agar expired ho.

Kya weak_ptr strong reference count badhata hai?

Nahi — yeh sirf weak count ko affect karta hai, isliye yeh object ko kabhi alive nahi rakhta.

Default smart pointer kaunsa use karna chahiye?

unique_ptr — sabse sasta aur sabse clear; shared_ptr par tab upgrade karo jab ownership genuinely shared ho.

Ek hi raw pointer se do shared_ptrs construct karna bug kyun hai?

Woh alag control blocks create karte hain → dono sochte hain ki sole owner hain → double-free.

Connections

RAII — woh principle jo smart pointers implement karte hain (lifetime = scope).
Move-semantics — isliye unique_ptr std::move se transfer hota hai.
Rule-of-Zero — smart pointers use karne se tum rarely destructors likhte ho.
Memory-leaks-and-dangling-pointers — woh bugs jo yeh prevent karte hain.
Reference-counting — shared_ptr ke andar ka algorithm.
Garbage-collection — contrast: deterministic destruction vs GC.