Concepts (C++20) — constraining templates — Hinglish notes

5.2.18 · Coding › C++ Programming

Concepts kyun exist karte hain?

Intuition Woh pain jo yeh solve karte hain

C++20 se pehle, templates duck-typed the: template<typename T> T add(T a, T b){ return a+b; } tab tak theek compile hota tha jab tak aap isse kisi aisi type ke saath instantiate nahi karte jiske paas operator+ nahi hai. Tab error template ke andar gehrai mein phat'ti thi, aksar kisi aisi line ko point karte hue jo aapne likhi hi nahi.

WHY: templates koi bhi type accept karte hain, lekin body sirf kuch types ke liye kaam karti hai. Requirement ko pehle se state karne ka koi tarika nahi tha. Concepts aapko requirement ko code ke roop mein likhne dete hain, isliye:

Errors call site pe point karti hain ("std::string satisfied nahi kiya Numeric"), andar ki guts par nahi.
Aap requirements par overload kar sakte ho (integral vs floating types ke liye alag function choose karo).
Requirement self-documenting ban jaati hai.

Concept KYA hota hai?

Definition Concept

Ek concept ek constexpr bool template hai jo given template arguments ke liye true ya false evaluate karta hai. Syntax:

template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

Yahan Numeric<int> true hai, Numeric<std::string> false hai. Yeh ek compile-time predicate hai, runtime par kabhi nahi chalta.

Inhe kaise likho aur apply karo? (4 syntaxes, same meaning)

Worked example

T ko Numeric constrain karne ke chaar tarike

// 1. Abbreviated function template (shortest)
auto sq(Numeric auto x) { return x * x; }
 
// 2. Constrained template parameter
template<Numeric T>
T sq(T x) { return x * x; }
 
// 3. requires-clause after the template head
template<typename T> requires Numeric<T>
T sq(T x) { return x * x; }
 
// 4. trailing requires-clause
template<typename T>
T sq(T x) requires Numeric<T> { return x * x; }

Chaar kyun? Yeh alag-alag ergonomics cover karte hain: (1) quick one-liners ke liye, (3)/(4) jab condition ek complex boolean expression ho jo ek single named concept na ho.

Concepts scratch se banana: `requires` expression

Do alag requires hote hain. Inhe confuse mat karo.

Worked example Haath se ek concept derive karna

Suppose karo hum chahte hain "types jinhe + kar sako aur result bhi T ho":

template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::same_as<T>;   // a+b compile bhi ho AND type T bhi ho
};

Yeh step kyun?

requires(T a, T b) test karne ke liye kalpnik variables declare karta hai (yeh actually kabhi create nahi hote).
{ a + b } ek compound requirement hai: expression valid hona chahiye.
-> std::same_as<T> a + b ki type ko constrain karta hai.

{ } ke andar chaar requirement kinds:

Kind	Example	Matlab
simple	`a + b;`	expression valid hai
type	`typename T::value_type;`	nested type exist karta hai
compound	`{ *p } -> std::convertible_to<int>;`	valid aur type constraint
nested	`requires Numeric<T>;`	doosra constraint hold karta hai

Figure — Concepts (C++20) — constraining templates

Concepts par overloading (killer feature)

Worked example Best-matching overload choose karo

template<std::integral T>        // (A)
void describe(T) { /* "integer" */ }
 
template<std::floating_point T>  // (B)
void describe(T) { /* "real number" */ }
 
describe(5);     // (A) call karta hai: int sirf integral satisfy karta hai
describe(3.14);  // (B) call karta hai: double sirf floating_point satisfy karta hai

Yeh kyun kaam karta hai: describe(5) ke liye, overload (B) ki constraint floating_point<int> false hai, isliye (B) candidates se silently remove ho jaata hai — koi error nahi, bas choose nahi hota.

Common mistakes ko steel-man karna

Worked example: ek generic `print_all`

Worked example "Ek range hai jise iterate aur stream kar sako" constrain karo

template<typename R>
concept Printable = requires(R r) {
    std::begin(r);                          // (1) iterable
    std::end(r);
    requires requires(decltype(*std::begin(r)) x) {
        std::cout << x;                     // (2) element streamable
    };
};
 
template<Printable R>
void print_all(const R& r) {
    for (const auto& x : r) std::cout << x << ' ';
}

Har step kyun?

(1) ensure karta hai ki range-for kaam kare.
(2) nested requires check karta hai ki har element << ho sake — call site par pakda jaata hai, loop ke andar nahi.
<int> wala vector isse satisfy karta hai; vector<NoStreamType> cleanly reject ho jaata hai.

Flashcards

C++20 concept kya hota hai, ek phrase mein?

Template parameters par ek named compile-time boolean predicate (ek constexpr bool template) jo templates ko constrain karne ke liye use hota hai.

Requires-clause aur requires-expression mein kya farq hai?

Clause ek constraint introduce karta hai aur ek bool evaluate karta hai (requires Numeric<T>); expression expressions list karke ek bool banata hai jo compile hone chahiye (requires(T a){ a+a; }).

{ a + b } -> std::same_as<T> kya check karta hai?

Ek compound requirement: a+b ek valid expression hona chahiye AUR uska type exactly T hona chahiye.

Jab do constrained overloads dono apply hote hain, kaun choose hota hai?

Zyada constrained wala (subsumption) — strictly stronger requirements jeet jaati hain.

Jab template ki constraint satisfy nahi hoti tab kya hota hai?

Template silently candidate set se remove ho jaata hai (error nahi hoti) jab tak koi candidate na bache.

Ek requires-expression ke andar chaar requirement kinds ke naam batao.

simple, type (typename T::x), compound ({e}->C), nested (requires C<T>).

Kya requires-expression runtime par code run karta hai?

Nahi — yeh sirf compile time par check karta hai ki har listed expression well-formed hai ya nahi.

Parameter x ko Numeric constrain karne ka shortest syntax batao.

auto f(Numeric auto x) — abbreviated function template.

Recall Feynman: ek 12-saal ke bachche ko samjhao

Ek khilona machine imagine karo jo sirf batteries se chalta hai. Purana C++ aapko kuch bhi daalne deta tha — kela, patthar — aur sirf phat'ta tha jab andar battery use karne ki koshish karta tha, ek confusing mess ke saath. Ek concept ek sticker hai slot par jo kehta hai "sirf batteries." Ab agar aap kela laao, machine politely kehti hai "nahi, is slot ko battery chahiye" bilkul darwaze par. Same idea: ek concept check karta hai "kya yeh type woh kar sakti hai jo mujhe chahiye?" kuch bhi tootne se pehle.

Connections

Templates — function & class templates
SFINAE and std::enable_if (purana, painful tarika jo concepts replace karta hai)
type_traits — std::integral, std::floating_point
Overload Resolution & Subsumption
constexpr — compile-time evaluation
Ranges library (C++20) (heavily built on concepts)
auto and decltype