Template specialization — full and partial

5.2.15 · Coding › C++ Programming

WHY specialization exist karti hai?

WHAT — teen cheezein jo distinguish karni hain?

HOW — har ek kaise likhein — first principles se

Step 1 — Primary template

template<class T>
struct TypeName {
    static const char* name() { return "generic"; }
};

Yeh step kyun? Yeh fallback hai. Jo bhi specialize nahi hua woh yahan aata hai.

Step 2 — Full specialization (SAARE params concrete)

template<>                    // empty <> = "koi free parameters nahi bache"
struct TypeName<int> {        // <int> = exact type jiske liye hum override kar rahe hain
    static const char* name() { return "int"; }
};

template<> kyun? Tumne har parameter fill kar diya, toh zero parameters bache — angle brackets empty hain. Naam ke baad <int> batata hai ki tum kaunsi instantiation replace kar rahe ho.

Step 3 — Partial specialization (KUCH params / ek shape)

template<class T>             // T abhi bhi free hai
struct TypeName<T*> {         // lekin humne SHAPE "T ki taraf pointer" match ki
    static const char* name() { return "pointer"; }
};
 
template<class A, class B>
struct TypeName<pair<A,B>> {  // koi bhi pair match karta hai, A aur B abhi bhi free hain
    static const char* name() { return "pair"; }
};

Yeh "partial" kyun hai? Tumne type ko ek concrete cheez par pin nahi kiya — tumne uski structure pin ki jabki T (ya A,B) open rakha. Toh yeh puri ek family cover karta hai.

Figure — Template specialization — full and partial

Worked Examples

Worked example Example 1 — full specialization ek custom message choose karta hai

template<class T> struct Printer { static string fmt(){ return "value"; } };
template<> struct Printer<bool> { static string fmt(){ return "true/false"; } };
 
Printer<double>::fmt();  // "value"   (primary)
Printer<bool>::fmt();    // "true/false" (full spec)

bool alag kyun hai? Humne explicitly exact type bool override kiya; baaki sab generic par fall through karte hain.

Worked example Example 2 — pointers ke liye partial (classic wala)

template<class T> struct IsPtr { static const bool value = false; };
template<class T> struct IsPtr<T*> { static const bool value = true; };
 
IsPtr<int>::value;   // false  (primary; int mein koi * shape nahi)
IsPtr<int*>::value;  // true   (partial T* match karta hai)

Yeh step (IsPtr<int*>) kyun? int* pattern T* mein fit hota hai jab T=int, toh partial fire hoti hai. Yahi exactly woh tarika hai jis se std::is_pointer jaise type-traits bane hain.

Worked example Example 3 — do mein se EK param fix karna

template<class A, class B> struct Pair2 { static const char* k(){ return "AB"; } };
template<class B> struct Pair2<int, B> { static const char* k(){ return "intB"; } };
 
Pair2<double,char>::k();  // "AB"    (primary)
Pair2<int,char>::k();     // "intB"  (pehla param int par pinned)

Yahan "partial" kyun? A ko int par pin kiya gaya lekin B abhi bhi free hai — sirf kuch parameters fixed hain.

Worked example Example 4 — ambiguity (failure ka steel-manning)

template<class A,class B> struct M { };
template<class A> struct M<A,int> { };   // <X,int> match karta hai
template<class B> struct M<int,B> { };   // <int,X> match karta hai
M<int,int> m;   // ERROR: ambiguous — dono match karte hain, koi zyada specialized nahi

Ambiguous kyun? M<int,int> ke liye dono patterns equally match karte hain; koi bhi dusre ka strict subset nahi → compiler guess karne se mana kar deta hai.

Common mistake Common traps (fix ke saath)

Full spec par template<> bhool jaana. Iske bina compiler sochta hai tum primary ko re-declare kar rahe ho. Fix: full spec hamesha template<> se shuru hota hai.
Specialization alag namespace mein rakhna. Ek specialization primary template ke same namespace mein honi chahiye. Fix: sahi namespace band karo/dobara kholо.
Pehle use ke baad specialize karna. Specialization declare/define pehle karni chahiye type pehli baar instantiate hone se. Kyun sahi lagta hai: "same type" hai. Fix: specializations primary ke paas rakho, usage se pehle.
Function template ko partially specialize karne ki koshish karna (upar wala callout dekho) → overloads use karo.
Partial spec mein default arguments. Partial specs naye default template args introduce nahi kar saktin; defaults primary par hote hain.

Flashcards

FULL specialization kaunse keyword sequence se shuru hoti hai?

template<> (empty angle brackets — zero free parameters bache hain).

Full vs partial specialization ek-ek line mein?

Full = saare template params concrete types par fixed; partial = kuch params fixed YA shape constrained, params abhi bhi free hain.

Kya function templates ko PARTIALLY specialize kar sakte hain?

Nahi — sirf fully. Partial jaisa behaviour ke liye overloading use karo.

Type int* ke liye, kaun jeetta hai: primary T ya partial T*?

T* — yeh zyada specialized hai (T ke strict subset ko match karta hai).

Compiler specializations mein ambiguity kab report karta hai?

Jab do partial specializations match karein lekin koi bhi dusre se zyada specialized na ho.

Specialization first use ke relative kahan declare honi chahiye?

Type ki pehli instantiation se pehle, aur primary ke same namespace mein.

Kaunsa real STL feature partial specialization se bana hai?

Type traits jaise std::is_pointer, aur std::vector<bool> (full-ish container specialization).

std::vector<bool> std::vector<int> se alag kyun hai?

Yeh ek specialization hai jo booleans ko bit-pack karti hai space bachane ke liye, isliye yeh real bool objects store nahi karta.

Specializations ki "partial ordering" kya hai?

Woh rule jo kehta hai spec A, B se zyada specialized hai agar A se match karne wali har type B se bhi match kare lekin ulta nahi.

Kya ek partial specialization ek NAYA default template argument add kar sakti hai?

Nahi — default template arguments sirf primary template par hote hain.

Recall Feynman: 12-saal ke bachche ko explain karo

Socho ek vending machine jo koi bhi filling maango uske liye sandwich banati hai — woh hai generic template. Lekin peanut butter ke liye, tumhare paas ek secret special recipe hai (jelly bhi dalo!) — woh hai full specialization: sirf us exact filling ke liye trigger hoti hai. Ab maano kisi bhi tin can mein aane wali cheez ke liye tum pehle use kholna chahte ho — woh hai partial specialization: ise koi farq nahi padta can mein kya hai, bas yeh "can-shaped" honi chahiye. Jab tum button dabate ho, machine check karti hai: koi exact special recipe hai? Use karo. Warna, koi "shape" recipe fit hoti hai? Sabse specific wali use karo. Warna, boring generic recipe use karo.

Connections

Templates — function and class basics
Type Traits and std::is_pointer
SFINAE and enable_if
Overload Resolution vs Specialization
std::vector<bool> special case
Tag Dispatch and Policy-based Design
constexpr if (C++17) — alternative to specialization