SFINAE — substitution failure is not an error

5.2.17 · Coding › C++ Programming

SFINAE KYA hai?

Do important boundaries:

Yeh sirf signature ke immediate context mein hone wali errors par laagu hota hai.
Function body ke andar ki error SFINAE nahi — woh hard error hai.

YEH rule KYUN exist karta hai?

Isse type system compile-time branching ka tool ban jaata hai ("concepts" ka ek primitive form).

Substitution actually KAISE kaam karta hai? (step-by-step derive karo)

Socho:

template <typename T>
typename T::value_type first(const T& c) { return *c.begin(); }

first(std::vector<int>{1,2,3}) call karo:

Deduce karo T = std::vector<int>. Kyun? const T& ke against argument matching.
Signature mein substitute karo → return type ban jaata hai std::vector<int>::value_type = int. Valid hai → candidate remain karta hai.

Ab first(42) call karo jahan 42 int hai:

Deduce karo T = int.
Return type mein substitute karo: int::value_type. int ka koi member value_type nahi hai → substitution failure.
SFINAE: yeh candidate silently drop ho jaata hai. Agar koi doosra overload exist nahi karta → error "no matching function" (NOT "int has no value_type").

Worked example Ek real

has_size detector banana — scratch se Goal: .size() wali types ke liye ek overload call karo, aur baaki ke liye doosra.

// Overload A: tabhi valid jab t.size() compile ho
template <typename T>
auto getSize(const T& t) -> decltype(t.size(), size_t{}) {
    return t.size();            // decltype(t.size(), size_t{}) kyun?
}                               // comma operator: t.size() ko
                                // VALIDITY ke liye evaluate karta hai, phir return type ke roop mein size_t deta hai.
 
// Overload B: fallback (worse match, koi constraint nahi)
template <typename T>
size_t getSize(...) { return 0; }   // ... = lowest priority overload

Step 1 (decltype(t.size(), size_t{})) kyun? t.size() ko decltype ke andar rakhne se compiler signature mein us expression ko check karne par majboor hota hai. Agar T ka koi size() nahi hai, toh yeh substitution failure hai → overload A gayab ho jaata hai.
Step 2 (... overload) kyun? Ek variadic ... parameter hamesha sabse bura match hota hai, isliye yeh tabhi jeet ta hai jab A available nahi hota.
Result: getSize(std::vector<int>{}) → 3; getSize(7) → 0. Koi hard error nahi.

Modern toolkit: `enable_if`

Definition

std::enable_if

template <bool B, typename T = void> struct enable_if {};        // koi ::type nahi
template <typename T> struct enable_if<true, T> { using type = T; }; // ::type hai

enable_if<true, R>::type R hai. enable_if<false, R>::type exist hi nahi karta → ise name karna substitution failure hai → SFINAE overload drop kar deta hai.

Worked example Integer-ness ke basis par do overloads

template <typename T>
std::enable_if_t<std::is_integral_v<T>, void> f(T) { /* integer path */ }
 
template <typename T>
std::enable_if_t<!std::is_integral_v<T>, void> f(T) { /* other path */ }

enable_if_t<cond, void> kyun? Jab cond false ho, ::type missing hai → woh overload self-destruct ho jaata hai. Kisi bhi T ke liye exactly ek hi survive karta hai.
Dono conditions mutually exclusive kyun honi chahiye? Agar kisi T ke liye dono true hote, toh aapko ambiguous overload hard error milta.

Figure — SFINAE — substitution failure is not an error

Common mistakes

Common mistake Same signature wale do

enable_if overloads

template <typename T, std::enable_if_t<cond,int> = 0> void g(T);
template <typename T, std::enable_if_t<!cond,int> = 0> void g(T);  // OK

Kyun log jal jaate hain: enable_if sirf return type mein daalna do otherwise-identical templates mein "redefinition" issues create kar sakta hai; safe idiom yeh hai ki defaulted non-type template parameter std::enable_if_t<cond,int> = 0 use karo.

Recall Feynman: 12-saal ke bache ko samjhao

Socho ek job interview hai jahan boss ke paas résumés (candidate functions) ka stack hai. Har résumé ke liye woh header padhta hai (naam, skills = signature). Agar header bakwaas hai ("Main Mars pe ud sakta hoon"), toh boss poora interview band nahi karta — woh bas woh résumé bin mein phenk deta hai aur agla padhta hai. SFINAE bilkul yahi hai: toota hua header résumé ko silently trash karwa deta hai. Lekin agar header theek lagta hai aur sirf interview ke andar woh banda bakwaas bolta hai (function body toot jaati hai) — tab boss furious ho jaata hai aur poori cheez crash ho jaati hai. Toh: toota header = quietly skip; andar toota = real error.

Flashcards

SFINAE kya stand karta hai aur matlab kya hai?

Substitution Failure Is Not An Error — agar template args ko function ki signature mein substitute karne se invalid type/expression bane, toh woh candidate overload resolution se silently remove ho jaata hai, hard error nahi aata.

SFINAE apply hone ke liye substitution failure kahan honi chahiye?

Signature ke immediate context mein (return type, parameter types, template parameter defaults) — function body mein NAHI.

Agar failure signature ki jagah function body mein ho toh kya hota hai?

Yeh HARD compile error hai; SFINAE wahan protect nahi karta.

std::enable_if<false, T>::type kya deta hai?

Kuch nahi — primary template ka koi ::type nahi hai, isliye ise name karna substitution failure hai jo overload drop kar deta hai.

std::enable_if<true, R>::type kya evaluate hota hai?

R (true ke liye partial specialization using type = R; define karta hai).

Trailing return type mein decltype(expr, ReturnType{}) kyun use karte hain?

Comma operator expr ko validity ke liye check karta hai (SFINAE enable karta hai) jabki poora decltype ReturnType deta hai.

Do enable_if-constrained overloads ki conditions mutually exclusive kyun honi chahiye?

Agar ek hi type ke liye dono valid hon, toh overload resolution ambiguous hota hai → hard compile error.

Jab SFINAE single candidate hata de toh kya error message milta hai?

"no matching function for call" — underlying member/expression error nahi.

Variadic ... parameter SFINAE fallback overload ke liye achha kyun hai?

Yeh sabse low-priority match hai, isliye tabhi choose hota hai jab saare constrained overloads remove ho jaate hain.

Connections

Templates and Type Deduction
std::enable_if and Tag Dispatch
decltype and Trailing Return Types
Concepts (C++20) — modern replacement jo SFINAE ko readable banata hai
Overload Resolution
Type Traits (std::is_integral, std::void_t)
void_t Detection Idiom