Templates — function templates, class templates: Question bank

5.2.14 · D5 · Coding › C++ Programming › Templates — function templates, class templates

True ya false — justify karo

Yeh test karta hai ki kya tum definitions mein actually believe karte ho, ya sirf words memorize kiye hain.

A template khud ek function ya class hota hai jise tum directly call kar sakte ho.

False. Template ek blueprint hai; kuch bhi runnable exist nahi karta jab tak type deduction koi concrete type pick na kare aur compiler usse instantiate na kare. maximum ko bina arguments ke call karna taaki T deduce ho — yeh kuch bhi compile nahi karta.

template<class T> sirf class types allow karta hai, jabki template<typename T> koi bhi type allow karta hai.

False. Type parameter ke liye dono 100% interchangeable hain; class yahan ka matlab "sirf classes" NAHI hai. typename sirf better readability ke liye add kiya gaya tha (aur baad mein dependent types ke liye ek alag disambiguation job bhi mili).

Ek unused template bhi tumhare binary ko machine code se bloat karta hai.

False. Code sirf un instantiations ke liye generate hota hai jo tum actually use karte ho; ek unused template zero machine code produce karta hai — isliye templates ki koi cost nahi hoti jo tumne maangi hi nahi.

Templates ka runtime cost hota hai hand-written per-type function ke comparison mein.

False. Generated code hand-written type-specific code ke equivalent hota hai, isliye runtime overhead zero hota hai — kaam poora compile time par hota hai.

Box<int> aur Box<double> same class share karte hain aur sirf alag values store karte hain.

False. Yeh completely different types hain, har ek independently instantiate hota hai; yeh koi code share nahi karte aur interchangeable nahi hain — ek Box<int>* kisi Box<double> ki taraf point nahi kar sakta.

Non-type template parameter jaise int N ek variable ho sakta hai jo user input se padha jaaye.

False. Non-type parameters compile-time constants hone chahiye (yahi poora point hai — T data[N] ko N tab jaanna chahiye jab code compile ho), isliye runtime value reject ho jaati hai.

Full specialization template<> primary template ke behaviour ko sabhi types ke liye badal deta hai.

False. Yeh sirf ek specific type ke liye alag implementation deta hai; baaki sabhi types generic version use karti rehti hain. Compiler most specialized match choose karta hai.

Templates aur macros basically same feature hain bas nicer syntax ke saath.

False. Macros text substitution hain bina type checking ke aur double-evaluation bugs ke saath; templates fully type-checked hain, scope respect karte hain, aur real typed code generate karte hain.

Error dhundo

Har line mein ek mistake hai jo kisi template rule ki wajah se hai. Rule ka naam batao.

maximum(3, 2.5); on template<typename T> T maximum(T,T).

T 3 se int deduce hota hai aur 2.5 se double → conflicting deductions, ek T dono nahi ho sakta. Fix: maximum<double>(3, 2.5) ya do type parameters use karo.

Poora template definition template.cpp mein rakhna aur header mein sirf declaration rakhna.

Body doosre translation units ke liye invisible ho jaati hai jo usse instantiate karne ki koshish karte hain → linker error: undefined reference. Templates ko header mein define karna zaroori hai taaki har jagah poora body dikh sake.

Class-template member ko class ke bahar T Box::get() const { ... } ke roop mein define karna.

Template head aur <T> qualifier missing hai — yeh hona chahiye template<typename T> phir T Box<T>::get(), kyunki out-of-class definition khud bhi ek template hai aur Box<T> specific template class ko name karta hai.

Box b(42); likhna (pre-C++17) yeh expect karte hue ki T int se deduce ho jaayega.

Class templates C++17 se pehle constructor se apna type deduce nahi kar sakte, isliye tumhe Box<int> b(42); likhna padega. (Function templates deduce karte hain; class templates historically nahi karte.)

template<> void print(bool b){...} ko ek free-standing specialization ke roop mein likhna jabki primary template bhool gaye.

Specialization sirf existing primary template ke against meaningful hoti hai; template<> kehta hai "yahan ek type ke liye override hai," isliye generic template<typename T> ... print pehle exist karni chahiye taaki compiler specialize kar sake.

#define MAX(a,b) ((a>b)?(a):(b)) use karna aur phir MAX(i++, j) call karna.

Macro double-evaluation — i++ do baar run ho sakta hai kyunki yeh expression mein do baar text-paste hota hai. Ek function template har argument ko exactly ek baar evaluate karta hai. Dekho Macros vs Templates.

Why questions

Har rule ke peeche ka "to kya fark padta hai". Mechanism ke saath jawab do, slogan ke saath nahi.

Kyon ek function template T deduce karta hai lekin ek class template (pre-C++17) nahi karta?

Ek function call argument types provide karta hai jinhein compiler T infer karne ke liye padhta hai; ek class name jaise Box bina kisi argument ke appear hota hai jisse deduce kiya ja sake (constructor type fix hone ke baad run hota hai), isliye tumhe khud Box<int> state karna padta hai.

Compiler ko instantiate karne ke liye sirf signature nahi balki poora body kyon dekhna padta hai?

Instantiation literally concrete type ke liye body ka code generate karta hai; sirf ek signature usse interface batata hai lekin stamp out karne ke liye kuch nahi deta, isliye woh machine code produce nahi kar sakta.

Templates type safety kaise maintain karte hain jahan void* + casts lose kar dete hain?

void* type erase kar deta hai isliye compiler ek int* ko double* ke saath mix karna nahi pakad sakta; ek template T ko poore body mein ek real type ke roop mein rakhta hai, isliye har operation us concrete type ke against checked hoti hai.

Non-type parameter N arrays ke liye kyun powerful hai?

Kyunki N ek compile-time constant hai, T data[N] stack par rehta hai ek size ke saath jo bake in hoti hai — koi heap allocation nahi, aur size compile-time checks aur inlining ke liye available hota hai.

Specialization exist kyun karta hai agar templates "one size fits all" hone chahiye?

Generic code ek type ke liye galat ho sakta hai (jaise bool ko true/false ki jagah 1/0 print karna); specialization tumhe sirf us case ko override karne deta hai jabki generic version baaki sab ke liye rakha rehta hai.

Templates STL aur Generic Programming mein central kyun hain?

Yeh ek implementation ko kisi bhi aisi type ke saath kaam karne dete hain jo needed operations support kare (jaise vector<T> kisi bhi T ke liye), jo exactly generic programming ka goal hai: algorithm ek baar likho, sabhi types ke liye reuse karo.

maximum ko T mein operator> support karne ki zaroorat kyun hai lekin kabhi mention nahi karta?

Body a > b use karta hai; requirement implicitly code jo karta hai usme hai. Instantiation sirf tab fail hoti hai (error ke saath) jab tum ek aisi T use karo jiske paas > nahi hai, use ke point par — definition par nahi.

Edge cases

Woh boundaries jo topic tumhein bhulane ka invitation deta hai.

Kya hoga agar tum maximum ko ek aisi type ke saath instantiate karo jiske paas operator> nahi hai, jaise ek struct?

Compilation instantiation ke point par fail hoti hai > missing hone ke bare mein error ke saath — template definition khud theek thi, error sirf tab appear hoti hai jab ek buri T body generate hone par majboor karti hai.

Kya ek completely unused function template final binary mein kabhi appear hota hai?

Nahi. Koi instantiation nahi toh generate karne ke liye kuch nahi hai, isliye yeh zero machine code contribute karta hai — aisa hai jaise tumne kabhi likha hi nahi.

Kya do source files mein se har ek Box<int> instantiate kar sakti hai bina multiple-definition linker error ke?

Haan. Template instantiations ko inline/weak symbols ke roop mein treat kiya jaata hai, isliye linker identical copies ko merge karta hai shikayat karne ki jagah — exactly isliye header definitions safe hain.

template<typename T = int> class C {}; tumhe kya likhne deta hai, aur C<> kyun zaroori hai?

Default tumhe type omit karne deta hai: C<> ka matlab hai C<int>. Empty angle brackets phir bhi zaroori hain taaki compiler jaane ki C ko template ke roop mein use kiya ja raha hai, plain class ke roop mein nahi.

Agar ek generic Printer<T> aur ek Printer<bool> specialization dono exist karte hain, toh Printer<bool> kaun sa use karta hai?

Most specialized match, isliye bool specialization jeetti hai; baaki sabhi types generic template par fallback karti hain.

Kya Array<double, 5> same type hai Array<double, 6> ke roop mein?

Nahi — non-type parameter N type ka hissa hai, isliye alag N values distinct, incompatible types deti hain (bilkul jaise alag T values dete hain).

Kya template<typename T, int N> mein T deduce ho sakta hai jabki N explicitly diya jaata hai, ek function template mein?

Haan — ek function template arguments se type parameters deduce kar sakta hai jabki non-type parameters jaise N explicitly supplied hote hain ya array sizes se deduce hote hain; sirf class templates (pre-C++17) constructor deduction se inkaar karte hain.

Recall Aage badhne se pehle ek-line self-test

Answers cover karo aur apne words mein explain karo: (1) code kab generate hota hai, (2) definition kahan rehni chahiye, (3) kyun Box<int> ≠ Box<double>. Agar koi bhi jawab sirf "kyunki yahi rule hai" hai, toh parent note dobara padho.