Concepts (C++20) — constraining templates: Foundations

5.2.18 · D1 · Coding › C++ Programming › Concepts (C++20) — constraining templates

Yeh page kuch bhi assume nahi karta. Parent page par use kiya gaya har symbol, keyword aur squiggle yahan unpack kiya gaya hai, ek aisi order mein jahan har item sirf usse pehle waalon par tikaa hai. Agar parent page ki koi line confusing lagi, woh symbol neeche dhundho.

0. Woh picture jis par hum baar baar aate hain

Template ko ek cookie-cutter ki tarah socho, aur ek type (ek label jaise "pura number" ya "text" — Section 1 mein properly define kiya gaya) ko aate ke ek tukde ki tarah. Cutter ek asli function ya class stamp karta hai jab tum use ek specific aata dete ho. Ek concept cutter par chipka ek sign hai: "sirf chocolate ya sugar ka aata — patther nahi." Sign door par check hota hai, cookie baad mein banaane ke baad nahi.

Figure s01 (neeche): teal cookie-cutter ek dashed blank slot carry karta hai jis par T likha hai; upar chipka orange sign padhta hai "sirf numeric dough"; daayein taraf, ek int plug fit hota hai (green true) jabki ek string block ko wapas kar diya jaata hai (orange false). Yeh har agli section ke liye mental image hai.

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

1. `type` — ek value kya hai

Picture: ek type ek socket ki shape hai. Ek round plug (int) ek round socket mein fit hota hai; woh square socket mein nahi jaayega (jahan whole number chahiye wahan decimal). + jaisi operations "prongs" hain — ya toh socket mein hain ya nahi.

Yeh topic ko kyun chahiye: concepts types ke baare mein sawaal hain. Isse pehle ki tum pooch sako "kya yeh type + support karti hai?", tumhe yeh maanna padega ki ek type ek cheez hai jo allowed operations ka ek fixed set carry karti hai. Dekho Templates — function & class templates jahan types plug in hoti hain.

template<typename T>   // "T ek type-shaped blank hai"
T add(T a, T b) { return a + b; }   // body us blank ko use karti hai

Picture: figure s01 ki cutter shape, jisme empty slot par T likha hai. Baad mein tum us slot mein ek real type fill karte ho (int, double, ...) — same cutter, alag alag cookies. Slot fill karne ka exact notation <...> hai, jo Section 5 mein unpack hota hai.

Yeh topic ko kyun chahiye: ek concept us blank se attached hota hai taaki restrict kar sake ki use kya fill kar sakta hai. Blank nahi toh constraint karne ke liye kuch nahi. Yeh ek prerequisite hai jis par poora parent note tikaa hai.

3. `constexpr` aur "compile time" — check kab hoti hai

Definition

constexpr keyword Kisi value ya function ke aage ==constexpr== likhne se compiler ko bata dete ho "tum ise compilation ke dauran, compile clock par compute kar sakte ho." Iska spelling ek single word constexpr hai jo type se pehle aata hai:

constexpr int limit = 3 * 4;   // 12 compiler dwara nikala jaata hai, run time par nahi
constexpr bool ok = true;      // ek compile-time true/false value

Ek concept exactly ek constexpr bool template hai — ek true/false value jo compiler program run hone se pehle settle kar leta hai.

Picture: do ghariyan. Clock A tab tik karti hai jab chef (compiler) recipe padh raha hota hai. Clock B tab tik karti hai jab diner (running program) kha raha hota hai. Ek constexpr value — aur har concept check — poori tarah Clock A par hoti hai — jab Clock B shuru hoti hai, tab tak saari constraints pass ho chuki hoti hain.

Yeh topic ko kyun chahiye: parent note kehta hai ek concept "ek constexpr bool template hai ... kabhi runtime par nahi chalta." Woh sentence meaningless hai jab tak tum yeh do ghariyan nahi dekhte. Dekho constexpr — compile-time evaluation.

4. `bool`, predicate, aur `true`/`false`

Picture: ek light switch — upar (true) ya neeche (false). Ek concept ek aisa switch hai jiski position is par depend karti hai ki tum use kaunsi type feed karte ho: ek whole-number type feed karo toh jal jaata hai, text feed karo toh neeche rehta hai.

Yeh topic ko kyun chahiye: ek concept ek predicate hi hota hai. Numeric<T> (jahan <...> Section 5 hai) padhta hai "kya T numeric hai?" aur true ya false se jal jaata hai. Parent note mein baaki sab us ek light switch ko compute karne ki machinery hai.

5. `<...>` — angle brackets (template ko uski type dena)

Picture: cutter par blank slot (figure s01) physically fill ho raha hai. <int> slot mein int drop karta hai.

Yeh topic ko kyun chahiye: parent mein har concept use — Numeric<T>, std::integral<T>, std::same_as<T> — angle-bracket substitution hai. <...> ko "blank fill karo" ki tarah pehchaanna zaroori hai. Ab jo blank (Section 2) aur filling notation dono define ho gayi hain, add<int> aur Numeric<int> poori tarah samajh aate hain.

6. `std::` — standard library ka name tag

Picture: ek labelled drawer. std drawer mein sab kuch standard-issue aur pehle se tested hai. std::integral, std::floating_point, std::same_as, std::convertible_to, std::begin, std::cout, std::string, std::vector sab wahan rehte hain.

Yeh topic ko kyun chahiye: Numeric jaisi concepts ready-made std:: concepts se bani hain. Ab jo std:: aur <...> dono define ho gayi hain, pehle loosely use ki gayi "text" (std::string) aur "ints ki list" (std::vector<int>) ki phrases poori tarah spell out ho gayi hain. Dekho type_traits — std::integral, std::floating_point.

7. `||`, `&&` — true/false jawaab combine karna

Picture: do switches ek saath wire kiye hue. || ke liye, koi bhi ek switch akela bulb jala deta hai. && ke liye, tumhe dono switches upar chahiye.

template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;
//  true agar T whole number hai  YA  T decimal number hai

Yeh topic ko kyun chahiye: parent ka pehla concept, Numeric, do simpler predicates ka or hai. Ek requires-expression ki requirements ki list implicitly ek and hai — har line compile honi chahiye.

8. `concept Name = ...;` — ek predicate ko naam dena

Picture: cutter par chipke sign par words likhna (figure s01). Pehle, rule kahin nahi tha; ab uske paas ek reusable label hai.

Yeh topic ko kyun chahiye: naam dene se ek darauni boolean formula ek readable word ban jaati hai jise tum reuse kar sakte ho aur error messages mein daal sakte ho ("std::string ne Numeric satisfy nahi kiya").

9. `requires` (do hain) — confusing twin keywords

Parent note stress karta hai ki do alag requires hain. Yahan woh picture hai jo inhe alag karti hai.

Definition Factory ke andar chaar tarah ki requirements

Parent mein chaar listed hain; yahan unki spelling hai taaki tum har ek ko dekhte hi pehchaan sako:

simple requirement — sirf ek expression ; par khatam hota hai, koi arrow nahi: a + b; ka matlab "a + b compile hona chahiye."
type requirement — typename word ek nested type naam leta hai: typename T::value_type; ka matlab "type T::value_type exist karni chahiye."
compound requirement — braces plus ek arrow: { a + b } -> std::same_as<T>; ka matlab "compile bhi ho AND result type fit bhi ho" (arrow -> Section 10 hai).
nested requirement — factory ke andar requires word: requires Numeric<T>; ek poori extra constraint bolt karta hai.

Key contrast: ek simple requirement (koi -> nahi) sirf poochha karta hai "kya yeh compile hoga?"; ek compound requirement ({ } ->) additionally result type bhi pin down karta hai.

10. Requirement mein `->`, plus `*`, `std::begin`, `decltype`

Parent ka decltype(*std::begin(r)) padhne se pehle, chaar chhote symbols ko naam chahiye.

Picture: arrow -> ek customs checkpoint hai expression compile hone ke baad: result ko sahi "type passport" dikhani padti hai. * ek ungli hai jo cursor ko std::begin se wahan tak follow karti hai jahan woh actual element point kar raha hai. Dekho auto and decltype.

Yeh topic ko kyun chahiye: compound requirement ({e} -> C) chaar requirement kinds mein se ek hai, aur parent ka Printable concept decltype(*std::begin(r)) use karta hai "element type" ko naam dene ke liye taaki test kar sake ki kya elements streamable hain.

11. Overloading & subsumption — zyada rules kyun jeette hain

Picture: do doormen. Door A: "sirf wholes." Door B: "sirf positive wholes." Ek +5 dono satisfy karta hai, lekin B stricter hai, toh bheed B se guzaari jaati hai. Ek unsatisfied door error nahi hai — woh guest simply us door ka use nahi kar sakta.

Yeh topic ko kyun chahiye: yeh parent ki "killer feature" hai. Dekho Overload Resolution & Subsumption. Dhyan do iska purana, clumsy tarika — SFINAE and std::enable_if — jo concepts replace karte hain.

Prerequisite map

Related tooling jo yeh feed karta hai: Ranges library (C++20) (jiske Printable-style range concepts parent ke worked example mein aate hain) aur poora parent note Hinglish version.

Equipment checklist

Ek type ko best kaise describe karein

compiler ka label hai ki ek value kis tarah ka data hai aur kaunse operations allowed hain.

template<typename T> ek phrase mein

ek type-shaped blank waala code jiska naam T hai, baad mein fill hoga.

template<...> ke andar typename vs class

identical — dono type placeholder declare karte hain.

Compile time vs run time

compile time = jab compiler code translate kar raha ho; run time = jab finished program execute ho raha ho.

constexpr keyword kya guarantee deta hai

value ya function compiler dwara compile time par compute ho sakti hai.

Ek bool hai

ek value jo exactly true ya false ho.

Ek predicate hai

ek sawaal jo bool se jawaab deta hai.

Numeric<int> ka matlab

Numeric predicate ko blank T = int set karke run karo, true ya false milega.

std:: prefix ka matlab

naam standard library toolbox ka hai.

std::vector<int> padhta hai

ek standard-library list jiske elements int hain (bracket = element blank fill karo).

A || B kab true hota hai

jab A, B mein se kam se kam ek true ho.

Ek concept definition kya karta hai

types par compile-time true/false test ko ek reusable naam deta hai.

requires-clause vs requires-expression

clause = ek gate jo existing bool attach karta hai; expression = ek factory jo har listed requirement compile hoti hai yeh check karke bool banati hai.

Kya braces { a + b } a+b compute karte hain?

Nahi — yeh test karte hain ki a + b compile hoga ya nahi, uski value nahi.

Ek simple requirement vs compound requirement

simple = ek expression ; par khatam, koi arrow nahi, sirf "compile hoga?" poochha; compound = { e } -> C, result type bhi pin down karta hai.

Ek type requirement kaisi dikhti hai

typename T::value_type; — assert karta hai ki ek nested type exist karti hai.

Ek nested requirement kaisi dikhti hai

requires Numeric<T>; — factory ke andar ek aur poori constraint bolt karta hai.

*std::begin(r) mein dereference * deta hai

woh value jo iterator (cursor) point kar raha hai — r ka pehla element.

std::begin(r) return karta hai

ek iterator (cursor) jo range r ke pehle element ko point karta hai.

{ expr } -> C check karta hai

expr compile hota hai AND uske result ka type concept C satisfy karta hai.

decltype(e) ka matlab

woh type jo expression e ki hogi.

Subsumption choose karta hai

zyada constrained overload jab kai apply hote hain.

Ek unsatisfied constraint cause karta hai

us candidate ko silently remove karna — error tabhi hoga jab koi bhi nahi bachega.