Question bank — Iterators — input, output, forward, bidirectional, random access, contiguous

True. Categories ek refinement chain banati hain, isliye random access ek strict superset hai — yeh --it ko rakhta hai aur uske upar it+n, it[n], etc. add karta hai.

False. Refinement sirf ek taraf jaati hai. Ek std::list iterator --it step kar sakta hai lekin $O(1)$ mein it+n jump nahi kar sakta, isliye yeh bidirectional par ruk jaata hai.

True. deque random-access hai, isliye subscripting constant-time hai — bas yeh contiguous nahi hai, jo memory layout ke baare mein ek alag promise hai.

False. Random access fast indexing guarantee karta hai, yeh nahi ki element 5 aur element 6 ek hi memory block share karte hain. Sirf contiguous iterators promise karte hain ki &*(it+n) == &*it + n.

False. Pure output iterators mein equality nahi hoti aur koi end sentinel nahi hota; unhe ek known-length source range se drive karna padta hai.

False. Input iterators single-pass hote hain — kisi bhi copy ko advance karna underlying stream ko consume kar leta hai, isliye doosri copy invalidate ho jaati hai. Multi-pass safety forward se shuru hoti hai.

True. Forward iterators multi-pass aur mutable hote hain (jab tak container const na ho), isliye x = *it aur *it = x dono allowed hain — yahi inhe input/output se alag karta hai.

False. std::sort ko idhar-udhar jump karke partition karne ke liye random-access iterators chahiye; list ke paas sirf bidirectional iterators hain, aur yehi exact reason hai ki list apna L.sort() member le kar aata hai.

True. Contiguous ek memory guarantee add karta hai (&*(it+n) == &*it + n), koi naya callable operation nahi. Operations random access ke identical hain.

True. Ek string apne characters ko ek contiguous block mein store karta hai (vector aur array ki tarah), isliye &*(s.begin()+n) == &*s.begin() + n hold karta hai.

list iterators bidirectional hain, isliye operator + exist nahi karta — yeh compile fail karega. std::advance(m, 2) use karo (ek $O(n)$ ++ ka loop).

Pehli read position ko store karke revisit karna input iterators ke liye illegal hai — yeh single-pass hain, isliye jaise hi aap advance karo, purani position invalid ho jaati hai.

Tum ek pure output iterator ko == se compare nahi kar sakte; output iterators mein equality nahi hoti. Iske bajaaye track karo ki tumne kitne elements likhe.

back_inserter output-only hai. Iske through read karna (x = *it) supported nahi hai; yeh sirf *it = value aur ++it support karta hai.

deque contiguous nahi hai, isliye p+1 element 1 ko point nahi kar sakta — memory chunks mein split hai. Sirf vector/array/string ko aise C API ko diya ja sakta hai.

Input iterators sirf forward move karte hain; negative advance ke liye --it chahiye hoga, jo unke paas nahi hai. Negative distances sirf bidirectional se upar valid hain.

Kyunki har container har operation cheaply perform nahi kar sakta — ek list $O(1)$ mein jump nahi kar sakti. Categories encode karti hain ki kaun se operations affordable hain taaki compiler sabse fast valid algorithm choose kar sake.

Tag dispatch random-access iterators ke liye it += n select karta hai (ek jump) aur bidirectional ke liye ek ++it loop, kyunki sirf random-access memory constant-time jump support karti hai.

Iska type compile time par overload select karta hai, isliye dispatch ka zero runtime cost hota hai — branch program run hone se pehle resolve ho jaata hai. Dekho Templates and Tag Dispatch.

copy apni destination ko *it = value se write karta hai aur ++it se advance karta hai — exactly output-iterator contract. Yeh destination ko kabhi read nahi karta, isliye kuch stronger ki zaroorat nahi.

Random access contiguous ke liye necessary hai (pehle it+n chahiye) lekin sufficient nahi — tumhe addresses bhi linear chahiye, jo random access akela promise nahi karta.

C APIs ek raw pointer ek flat array mein expect karti hain jahan p+n n-th element hai. Sirf contiguous guarantee &*(it+n) == &*it + n &*container.begin() ko us tarah behave karati hai. Compare karo plain Pointers and pointer arithmetic se.

Contiguous — sabse strongest. Ek pointer read/write, ++, --, +n, subtraction, ordering support karta hai, aur iske addresses by definition memory mein linear hain.

Kuch nahi halta — zero steps har category ke liye valid hai, including input, kyunki koi direction ya jump actually perform nahi hoti.

Haan. find *it se read karta hai, ++it se advance karta hai, aur positions ko != se compare karta hai — yeh sab input/forward se upar supported hain, isliye yeh sabse wide range of containers par kaam karta hai.

Har category jisme equality ho — input, forward, bidirectional, random access, contiguous. Pure output iterators nahi kar sakte, kyunki unke paas na == hai na end sentinel.

Nahi. Key lookup tree par ek container operation hai; iterator sirf sorted sequence ko ++/-- se walk karta hai, isliye yeh bidirectional hai, random access nahi.

Nahi. Ek const_iterator *it reads allow karta hai lekin *it = x forbid karta hai; category (contiguous) traversal power describe karti hai, jabki const-ness independently mutability govern karti hai.