Foundations — Lambda expressions — capture list (by value, by reference)

5.2.22 · D1 · Coding › C++ Programming › Lambda expressions — capture list (by value, by reference)

Parent note padne se pehle tumhe lagbhag ek dozen choti-choti ideas khud se samajhni chahiye. Yeh page har ek idea ko bilkul zero se build karta hai, us order mein jisme ek doosre pe depend karti hain. Yahan koi bhi symbol use nahi hoga jab tak pehle draw na kar liya ho.

1. int aur doosre types — basic types (ek box kya hold kar sakta hai)

Common built-in types jo tumhe pehchanne chahiye:

• int → ek poora number (default number type).
• double → decimal point wala number (jaise 3.14).
• char → ek single character (jaise 'A').
• bool → ek truth value: true ya false.

2. Variable ek labelled box hai memory mein

Figure dekho: naam n ek sticky label hai, box memory mein ek real location hai (uska ek address hai — ek ghar ka number), aur value 10 woh hai jo abhi andar baitha hai. Yeh teen alag-alag cheezein hain, aur poora capture-list topic isi ke baare mein hai ki lambda inme se kise grab karta hai.

• Naam se tumhara code us box ko refer karta hai.
• Address batata hai ki box physically kahan hai.
• Value hai abhi andar kya hai — aur yeh baad mein change ho sakta hai (n = 99; contents ko swap kar deta hai).

3. = ka matlab hai "andar daalo", "barabar hai" nahi

Yahi ek distinction parent ke Example 1 (n=1 phir n=99, lambda phir bhi 1 print karta hai) ko discuss karna possible banati hai: box ki contents overwrite ho gayi, lekin pehle li gayi copy nahi.

4. Address-of operator &n — "box ka ghar ka number lo"

int n = 10;
&n;   // ek expression: box n ka address (location)

5. Scope — box kahan exist karta hai, aur kab marta hai

Figure mein, box x sirf function make() ke andar hi zinda hai. Jaise hi make() return karta hai, poori shelf saaf ho jaati hai — x ka box ab exist nahi karta. Jo bhi us box ka address (&x) hold kar raha tha, woh ab empty space ki taraf point kar raha hai.

6. Copy vs alias (yahi poora topic hai)

Figure mein dono side by side dikhaye hain:

• Left (copy): do alag boxes. Original ko 99 kar do; copy ab bhi 1 dikhata hai. → Yeh hai capture by value [n].
• Right (reference &): ek box, do labels. Kisi bhi label se change karo aur dono "99 dekhenge". → Yeh hai capture by reference [&n].

7. auto — "compiler, type tum batao"

auto add = [](int a, int b){ return a + b; };  // iska type unnameable hai -> auto

8. struct aur brace-initialization — woh box jo bahut saare boxes hold karta hai

struct Point {      // blueprint: do boxes ek saath bundled
    int x;
    int y;
};
Point p{3, 4};      // ek Point banao; x ko 3 milta hai, y ko 4 (brace-initialization)

Yeh matter karta hai kyunki agli section ka functor — aur har lambda — exactly ek aisa hi struct hai, aur uski captured variables uske members hain, jo lambda object ke janam par brace-init se fill hote hain.

9. Ek function jo ek value ke andar rehta hai: the functor

struct Adder {
    int base;                                         // ek member box
    int operator()(int x) const { return x + base; }  // call syntax: a(5)
};
Adder a{10};   // brace-init: base ko abhi 10 milta hai
a(5);          // 15  -- function call jaisa lagta hai, actually a.operator()(5) hai

10. Copy KAB hoti hai — creation par, call par nahi

Figure mein timeline ko left se right padho:

1. int n = 1; — box n mein 1 hai.
2. auto f = [n]{ return n; }; — creation: copy yahan li jaati hai, isliye f ke andar member box 1 par set ho jaata hai aur freeze ho jaata hai.
3. n = 99; — yeh sirf bahar ke box ko overwrite karta hai; f ke andar member copy pehle hi ban chuki thi aur untouched hai.
4. f() — call: yeh apna khud ka member box padhta hai, jisme ab bhi 1 likha hai.

11. const aur mutable — read-only lock aur uski chaabi

Isliye parent kehta hai ki by-value capture by default read-only hoti hai. Compiler lambda ka operator() default mein const generate karta hai, isliye uska member copy touch nahi kiya ja sakta.

Figure mein generated closure struct dikhaya hai: upar members (captures), neeche ek const operator(). Members par ek padlock hai const ki wajah se; word mutable woh chaabi hai jo ise hata deti hai.

12. this pointer — enclosing object ko capture karna

struct Widget {
    int value = 5;
    auto getReader() {
        return [this]{ return value; };  // [this] -> lambda value dekh sakta hai
    }
};

13. Generalized captures — init-capture aur move-capture (C++14)

int y = 7;
auto f = [x = y + 1]{ return x; };   // member x 8 se start hota hai

auto data = std::make_unique<int>(10);
auto job = [p = std::move(data)]{ return *p; };  // ownership lambda mein move hui
// data ab khaali hai; lambda ke andar p us int ka maalik hai

14. Notation ko sath mein jodna

Prerequisite map

Left side sab "box" ideas hain; H (lambda) ko feed karne wali sab cheezein woh hain jo parent page silently assume karta hai ki tumhare paas pehle se hain.

Equipment checklist