5.2.21 · D1Iterators — input, output, forward, bidirectional, random ac
Ek iterator ek chhota sa object hai jo ek collection ke ek element par raki hui ungli ki tarah kaam karta hai, jiske paas do basic powers hain: "jo element main point kar raha hun use read/write karo" aur "mujhe next element par le jao". Baaki sab — categories, ++, --, +n — bas ek list hai ki is particular ungli ko kaun se moves karne ki ijazat hai aur kitni tezi se .
parent note mein chhah iterator categories samajhne se pehle, aapko kuch chote symbols mein fluent hona padega. Yeh page unhe ek-ek karke bilkul zero se build karta hai. Hum dheere chalte hain aur ek aisi order mein jahan har idea sirf upar wale ideas par lean karta hai.
Sabse concrete picture se shuru karte hain: boxes ki ek row, jisme har ek mein ek value hai.
Definition Container (informal)Ek container woh cheez hai jo kai saari values store karti hai aur aapko unhe visit karne deti hai. C++ ke examples mein: std::vector, std::list, std::set. Dekho STL Containers — vector, list, deque, map .
Picture: upar wali boxes ki row. Har box ek element hai; andar ki value element ki value hai.
Hum abhi yeh nahi bol rahe ki boxes memory mein kaise laid out hain. Yahi difference (sab-ek-line-mein vs. bikre hue) aage categories ko separate karega. Abhi ke liye: boxes, values, bas.
it
Parent note mein letters it sirf ek iterator ke liye variable name hai — ek aisa object jo ek element ko "point" karta hai. Ise ek finger ki tarah socho jo ek box par ruki hui hai.
Picture: neeche figure mein chhota sa orange arrow, bilkul ek box ke neeche baitha hua.
Yeh topic isko kyun chahta hai: find aur copy jaisi algorithms kabhi directly container ko touch nahi karti; woh sirf ek finger pakadti hain aur use move karti hain. Yahi poora decoupling trick hai.
Finger box se ek alag object hai. Aap ek hi row par do fingers rakh sakte ho, ek ko move kar sakte ho, aur doosri wahin rahi — yeh idea (multi-pass) baad mein important ho jaata hai.
*it
Ek iterator ke aage * ka matlab hai "jo element finger ruki hui hai use mujhe do ". *it padhna value laata hai; *it = 7 likhna us box mein 7 dalta hai.
Picture: ek arrow finger se upar box mein jaata hai, value nikaalta (ya daalta) hai.
box.value kyun nahi?
Star pointers se liya gaya hai (dekho Pointers and pointer arithmetic ). Ek pointer p ek address hold karta hai, aur *p wahan jo hai use fetch karta hai. Ek iterator ne purposely wahi spelling copy ki hai: agar aap pointers jaante hain, toh aap iterators bhi jaante hain. Isliye parent ek iterator ko "generalized pointer" kehta hai.
it aur *it ek hi cheez hain."
Yeh sahi kyun lagta hai: aap hamesha inhe saath likhte lagte ho.
Fix: it finger hai (ek position); *it woh value hai jo woh touch karta hai. it == end positions compare karta hai; *it == 7 values compare karta hai. Inhe confuse karna number-one beginner bug hai.
++it
++it finger ko ek box daayein move karta hai. Yeh finger ko change karta hai, boxes ko nahi.
Picture: finger box k k + 1 Yeh topic isko kyun chahta hai: har iterator category ++it support karti hai. Yeh ek universal move hai. Jo category aage bhi step nahi kar sakti woh useless hogi.
--it (figure mein, gray arrow jo baayein jaata hai) mirror move hai: ek box baayein . Notice karo yeh faded drawn hai — har finger ko peechhe jaane ki ijazat nahi hoti. Yahi restriction exactly bidirectional vs forward define karegi baad mein.
begin() aur end()
begin() pehle box par ek finger deta hai.end() ek phantom box par finger deta hai jo last se ek aage hai — ek stopping post, real element nahi.
Picture: begin box 0 ke neeche; end final box ke baad, khali jagah ke upar hover karta hua.
Intuition "One past the end" kyun, "last element" kyun nahi?Past-the-end marker se, ek loop cleanly padhta hai: "tab tak chalta raho jab tak meri finger end nahi ho jaati." Jis moment finger end tak pahunche, ruk jao. Agar end last real box hota toh aapko final step ke liye special case banana padta. Half-open range [ begin , end ) begin == end hota hai.
== / inequality !=
it1 == it2 poochta hai "kya yeh do fingers ek hi box par hain?" it1 != it2 iska ulta hai.
Picture: do fingers; == tabhi true hota hai jab woh same box ke neeche baithi hon.
Yeh topic isko kyun chahta hai: upar wala loop it != c.end() par jeeta marata hai. Agar "kya main stop-post par aa gaya?" test karne ka koi tarika na hota, toh aap kab rukna hai yeh nahi jaante.
Note karo yeh positions compare karta hai, kabhi values nahi. Do alag boxes par do fingers jo same number hold karti hon equal nahi hain.
Definition Random-access arithmetic
it + n = ek finger jo n boxes ek hi leap mein daayein .it - n = ek leap mein n boxes baayein.it[n] = n boxes daayein ki value, yaani *(it + n).
Picture: ek lamba arrow box k k + n
Intuition Crucial word: "one leap mein" (cost)Koi bhi ++it ko n k + n it + n kuch zyada claim karta hai: yeh ek constant-time step mein wahan pahunchta hai, chahe n kitna bhi bada ho. Yeh tabhi possible hai jab boxes is tarah laid out hon ki finger target address directly compute kar sake — jo vector (boxes ki line) ke liye true hai lekin list (arrows se linked bikre boxes) ke liye false hai. Yahi ek cost distinction parent ki category hierarchy ki heart hai, aur yeh seedha Pointers and pointer arithmetic se aata hai.
it2 - it1
Do fingers ko subtract karne se pata chalta hai ki woh kitne boxes apart hain (ek count, jaise 5).
Picture: do fingers ke beech ke gaps count karo.
Yeh topic isko kyun chahta hai: end - begin range ka size hai. Sirf woh categories jo fast jumping kar sakti hain woh ise ek step mein compute kar sakti hain.
Definition Order comparison<
it1 < it2 poochta hai "kya it1 ka box it2 se zyada baayein hai?"
Picture: row ke saath positions compare karo; baayein chota hai.
Yeh topic isko kyun chahta hai: woh algorithms jo ek range ko adha karte hain (jaise std::sort, dekho STL Algorithms — sort, find, copy ) poochte hain "kya yeh finger us se pehle hai?". Iske liye positions ki seedhi line chahiye — phir se sirf random-access family qualify karti hai.
Yeh parent mein sabse dense symbol hai, toh hum ise letter by letter unpack karte hain.
&
&x ka matlab hai "==woh memory address jahan x rehta hai==" — ek value ke liye house number ki tarah. Pointers and pointer arithmetic se.
Picture: ek box ke neeche ek label likha "house #1000".
Ab &*(it + n) ko right-to-left, ek symbol at a time padho:
it + n — finger n *(...) — us finger ke neeche ki value (§2).&(...) — us value ka address.
Toh &*(it+n) hai "box ka house number jo n &*(it+n) == &*it + n kehta hai:
Intuition Yeh random access sezyada strong kyun hai
Ek deque it + n fast kar sakta hai (random access) phir bhi boxes alag-alag chunks mein store karta hai, toh house numbers chunks ke beech jump karte hain — even-line promise toot jaata hai. vector/array/string har box ko ek unbroken block mein rakhte hain, toh promise hold hota hai aur aap &v[0] ko ek plain C function ko de sakte ho jo pointer expect karta hai. Contiguous = random access plus even-address line.
⊂
A ⊂ B har A ek B bhi hai, aur B ke paas zyada hai ". Parent likhta hai
Input ⊂ Forward ⊂ Bidirectional ⊂ RandomAccess ⊂ Contiguous Reading: pehli category ki har capability baad wali mein rakhi jaati hai, jo phir aur add karti hai. Ek contiguous iterator woh sab kar sakta hai jo ek input iterator kar sakta hai, plus bahut kuch zyada.
Picture: nested rings — ek chhota circle ek bade circle ke andar ek aur bade ke andar.
Isliye parent ki operation table kabhi bhi daayein jaate waqt ✓ nahi hatati : jab ek power aati hai, toh saari rich categories use inherit karti hain.
Ek tag ek empty label-struct hai (jisme koi data nahi hota) jiska sirf kaam hai yeh naam batana ki iterator kis category ka hai, jaise std::random_access_iterator_tag.
Picture: finger par ek coloured sticker jisme likha ho "main ek random-access finger hun."
Yeh topic isko kyun chahta hai: compile time par library yeh sticker padhti hai taaki sabse fast code path choose kar sake — yeh Templates and Tag Dispatch hai, jo iterator_traits and type introspection ke through surface hota hai. Jab program run hota hai tab koi sticker-reading nahi hoti; iska koi cost nahi. Modern Ranges library (C++20) bhi inhi category ideas par build karta hai.
Iterator it = finger on one box
star it = read or write the value
plus plus it = step forward
begin end and the stop post
equals and not equals compare positions
it plus n = jump many boxes fast
address of gives contiguous line
Refinement chain of six categories
Category tags select fast code at compile time
Daayein side cover karo aur zor se jawab do. Agar koi jawab fuzzy lage, toh parent note se pehle woh section dobara padho.
Ek word mein it (ek iterator) kya represent karta hai? Ek collection ke ek element par point karti hui finger.
it aur *it mein kya farq hai?it position hai (finger); *it uske neeche ki value hai.
++it kya change karta hai — boxes ya finger?Sirf finger; woh ek box daayein slide karti hai.
end() kahan point karta hai, aur last element par kyun nahi?Last se ek box aage , taaki loops it != end se cleanly ruk sakein.
Kya it1 == it2 positions compare karta hai ya values? Positions — same box hai ya nahi, value chahe kuch bhi ho.
it + n ++it ko n baar press karne se aage kya extra promise karta hai?Yeh target tak ek constant-time leap mein pahunchta hai, chahe n kitna bhi bada ho.
&*(it + n) ko plain words mein right-to-left padho.Us value ka address jo us finger ke neeche hai jo n boxes daayein hai.
Categories ke liye A ⊂ B ka kya matlab hai? A ki har capability B mein rakhi jaati hai, aur B aur zyada add karta hai (refinement).
Ek deque it + n kar sakta hai lekin contiguous test fail kyun karta hai? Uske boxes alag chunks mein rehte hain, isliye addresses ek even line mein nahi badhte.
Category tag kya hai aur kab padha jaata hai? Ek empty label-struct jo category ka naam batata hai, compile time par fastest code choose karne ke liye padha jaata hai.
