Modern C: C23 features aur adoption
C23 language/library changes, remaining contracts aur feature-by-feature implementation support samjhein.
Is chapter mein11 sections
C23 useful language aur library facilities add karta hai. Use karne se pehle feature ka meaning aur compiler-library support check karein. Nayi capabilities ko un bounds, lifetime aur argument rules ke saath samjhenge jo ab bhi required hain.
C23-marked examples ko corresponding language/library facilities chahiye. Yeh reader ke C17 baseline se separate hain. Feature illustration har installed compiler/target ko poori revision support karne ka promise nahi.
1. Published revision, selected mode aur actual support
31 October 2026 ke check mein WG14 C23 ko published aur next main revision C2y ko unpublished list karta hai. Newer proposals aur separate Technical Specifications silently C23 nahi ban jaate. Draft year aur nickname differ karein toh standards timeline dekhein.
Implementation support ke layers hain: compiler mode/version, target, supplied headers, linked library aur runtime environment. Support tables facilities separately track karti hain. Old compiler ka preview mode kuch final C23 forms accept karke bhi sab implement nahi kar sakta; newer flag bhi har optional library feature ka inventory nahi.
2. Nayi spellings aur named constant objects
bool, true, false, alignas, alignof, static_assert aur thread_local C23 language spellings hain. Paanch older underscored alternatives recognized lekin obsolescent hain. nullptr predefined null-pointer constant hai; stddef.h nullptr_t type name deta hai. nullptr_t aur NULL extra keywords nahi.
#include <assert.h>
#include <stddef.h>
constexpr int capacity = 4;
static_assert(capacity == 4);
int main(void)
{
auto count = capacity;
bool ready = true;
int *cursor = nullptr;
assert(count == 4 && ready && cursor == nullptr);
return 0;
}
constexpr constrained initialization ke under named constant object deta hai. auto supported initializer form se fixed type infer karta hai; dynamically typed variable nahi. Yeh C++ constexpr-function support ya har C++ auto declaration ki permission nahi. Connected rules ke liye constant expressions aur keyword index dekhein.
nullptr ka apna type pointer types se distinct hai. Variadic functions ke argument-type contracts phir bhi apply karte hain. C17/C23 shared examples mein %p se pehle object pointer ko explicitly void * convert karein; har null-looking value ko har variadic API ke liye suitable assume na karein. Null pointer character terminator ya all-zero representation bhi describe nahi karta.
3. Types, qualification aur bit-precise values
#include <assert.h>
int main(void)
{
const int original = 7;
typeof_unqual(original) editable = original;
typeof(original) *reader = &original;
editable += 1;
assert(editable == 8 && *reader == 7);
return 0;
}
typeof expression/type name se type derive karta hai. typeof_unqual top-level aur atomic qualification remove karta hai: editable mutable int hai aur reader const int ka pointer. Pointed-to const remove nahi hota. Ordinary operands unevaluated hain, lekin variably modified types evaluation cases introduce karte hain; “typeof kuch evaluate nahi karta” overbroad hai.
Optional: bit-precise value width, promised storage size nahi
#include <assert.h>
int main(void)
{
unsigned _BitInt(9) flags = 0x1FF;
flags += 1;
assert(flags == 0);
return 0;
}
Unsigned _BitInt(9) 0 se 511 tak values represent karta hai. Unsigned type mein wapas conversion yahan modular result 0 deta hai. Signed _BitInt(N) mein N sign bit include karta hai aur kam se kam 2 hona chahiye (unsigned N, 1 se start ho sakta hai); BITINT_MAXWIDTH se supported maximum specified hai. Requested value width ka matlab sizeof mein exactly N storage bits nahi. Layout, rank/conversion rules aur target support matter karte hain.
C23 explicit underlying-type forms aur broader enumerator handling se enums extend karta hai. Decimal floating types conditional facilities hain. Har new type universally available assume karne ke bajay enumeration rules aur implementation documentation dekhein.
4. Function declarations, initialization aur source notation
| Change | Meaning | Boundary |
|---|---|---|
| Empty function parameter list | C23 declaration mein int f(); no-parameter prototype hai. | C17 declaration parameter-type information nahi deti. int f(void) dono mein explicit hai. |
| Old identifier-list definitions | Old K&R definition form removed hai. | Typed parameters use karein; history syntax ko current teaching style mat banayein. |
| Empty initializer {} | Permitted forms object/type rules se empty initialization karti hain. | Typed zero initialization universal all-zero byte-format promise nahi. |
| Binary literals/digit separators | 0b101010 aur 1'000'000 notation clearer banate hain. | Clear literal se range/type/conversion obligations nahi badalti. |
| #elifdef / #elifndef / #warning | Additional conditional/diagnostic preprocessing facilities. | Preprocessing runtime control flow se separate hai. |
| #embed | Preprocessing mein resource ko integer-constant tokens mein expand karta hai. | Runtime file-read API nahi; resource aur implementation limits apply karti hain. |
Context ke liye function contracts, initialization aur preprocessing dekhein. [[nodiscard]], [[maybe_unused]] aur [[fallthrough]] ke individual rules hain. [[noreturn]] aur function-property attributes semantic contracts assert karte hain. Standard attributes ignore karne se correct program ke semantics nahi badalte; false asserted property program invalid ya execution undefined kar sakti hai. Yeh general warning-suppression/correctness switch nahi.
5. Library additions: checked arithmetic aur bit utilities
<stdckdint.h> ki checked arithmetic detect karti hai ki integer result representable hai ya nahi. Destination accept karne se pehle returned failure flag check karein; overflow result ko mathematical answer na samjhein.
#include <assert.h>
#include <limits.h>
#include <stdckdint.h>
int main(void)
{
int candidate = 0;
bool overflow = ckd_add(&candidate, INT_MAX, 1);
assert(overflow);
bool fits = !ckd_add(&candidate, 40, 2);
assert(fits && candidate == 42);
return 0;
}
First operation overflow report karta hai aur result value inspect nahi hoti. Second fit hokar 42 deta hai. Yeh pehle overflowing ordinary signed addition evaluate karke baad ki comparison se repair karne jaisa nahi.
<stdbit.h> bit utilities deta hai. Example unsigned argument 0xA0 ke do set bits count karta hai; har facility ke specified type aur zero-input rules follow karein.
#include <assert.h>
#include <stdbit.h>
int main(void)
{
unsigned count = stdc_count_ones(0xA0u);
assert(count == 2);
return 0;
}
Other additions mein allocated copies ke liye strdup/strndup (failure check aur free se release), contract ke under overwrite remove na hone ke liye memset_explicit, aur required allocation metadata ke saath free_sized/free_aligned_sized hain. Explicit wipe har secret copy disappear hone ka proof nahi; sized free original size/alignment guess karne ki permission nahi. Header presence, feature-test macro ya successful parser check akela complete usable runtime implementation prove nahi karta.
6. Naye representation rules old obligations nahi hatate
C23 standard signed integer types ke liye two’s-complement require karta hai. Ordinary signed overflow undefined rehta hai. Negative signed right shift aur unrepresentable signed integer conversion specified implementation choices retain karte hain. Pointer bounds, access types, lifetimes aur synchronization rules bhi apply karte hain.
Non-null pointer ke liye C23 zero-size realloc request ko undefined behavior banata hai. Separate null-pointer branch malloc ke zero-size rules follow karta hai; dono ko ek slogan mein mix na karein. Clear policy explicit free se release karti hai aur zero-size realloc ko portable release operation nahi banati.
7. Adoption ko small engineering change ki tarah review karein
Supported mode/target choose karein; specific feature/library confirm karein; minimal example compile karein; real interface/failure paths test karein; project require kare toh C17 alternative rakhein. Ek extension accept hone se team ka portability contract update nahi hota.
Syntax change karte waqt ownership aur valid-input assumptions preserve karein. Removed/deprecated forms, warning policy, har translation unit ke flags, headers aur dependent libraries review karein. Baseline document karein taaki learner program reproduce kare, intended “modern C” guess nahi.
8. Thought check: two’s-complement signed wrap safe hai?
Representation two’s complement hai. Kya ordinary signed increment overflow hone ke baad check kar sakte hain?
Nahi. Representation aur arithmetic validity alag rules hain. Pehle fit prove karein, supported checked facility use karein, ya deliberately modular unsigned domain choose karein.
Sources aur aage ki reading
- WG14 — current project/revision status
- WG14 N3096 — 6.4, 6.6–6.7, 6.10, 7.18, 7.20, and 7.24.3.7
- ISO — published C23 revision
- GCC — feature-by-feature C support
- Clang — feature-by-feature C support
Aage badhne se pehle
- C23 apne contracts ke saath language aur library features add karta hai.
- Compiler support, library support aur target availability alag checks hain.
- Nayi syntax bounds, lifetime, range ya argument-type requirements remove nahi karti.
In ideas ko alag rakhein
- Language mode / Complete support
- C23 mode select karne se target par har language aur library facility implemented hona establish nahi hota.
Several toolchains wale program mein C23 facility use karne se pehle use kaise verify karenge?
Optional: bolkar samjhein ya note rakhein. Tayyar hon toh aage badh sakte hain.Apni understanding check karein
Optional hai. Answers save ya send nahi hote; chapter kabhi lock nahi hota.
Har choice ki explanation padhein
- Sirf source file .c par end hoti hai.
Extension se na language edition establish hoti hai na feature support.
- Ki ek unrelated C23 example compile hua.
Ek feature ka support har language aur library change ka support prove nahi karta.
- Selected language mode aur us feature ka actual compiler/library support.
✓ Sahi reasoning. Language edition aur implementation support alag hain. Documented support aur relevant feature check use karein.
C23 adoption
Earlier edition ka quick reference
Existing section links aur saved passages ke liye retained. Exact corrections source review mein documented hain.
C17 ek pure bug-fix release thi jisme koi naya language feature nahi tha, lekin C23 (jo ISO/IEC 9899:2024 ke roop mein publish hui) C11 ke baad ki sabse substantial revision hai — aur isi wajah se total keyword count 50 se aage badh gaya hai. Iske sabse notable additions yeh hain:
nullptraurnullptr_t:nullptrpredefined null-pointer constant aur keyword hai.nullptr_tiska type name hai jo<stddef.h>deta hai; yeh additional keyword nahi. Yeh type pointer aur arithmetic types se distinct hai aur pointer type mein null pointer value ke roop mein convert hota hai.NULLavailable rehta hai.constexpr: Constant-expression initialization rules follow karne wala constant object define karta hai. C23 mein yeh object facility hai, C++-style constexpr functions nahi. Ordinaryconst intautomatically integer constant expression nahi hota.typeofaurtypeof_unqual: Expression ya type name se type derive karte hain.typeof_unqualtop-level qualifiers aur atomic qualification hatata hai. Ordinary operand evaluate nahi hota, lekin variably modified types mein evaluation cases hain; “hamesha unevaluated” kehna sahi nahi.- Familiar naam ab keywords hain.
bool,true,false,static_assert,alignas,alignofaurthread_localko C23 mein purane header macros ki zaroorat nahi. Purani underscore spellings obsolescent alternatives hain; iska matlab purane macros ab bhi defined hone ki guarantee nahi. C23 se pehle relevant macros naam ke hisaab se<stdbool.h>,<assert.h>,<stdalign.h>ya<threads.h>se milte the. _BitInt(N)— Bit-precise integer types jinki specified width value range determine karti hai; signed type mein sign bit included hai aur implementation ki supported maximum width apply hoti hai. Isse object ke storage bits exactly utne hi hone ka promise nahi milta.- Standard attributes —
[[deprecated]],[[maybe_unused]],[[nodiscard]], aur[[fallthrough]]jaise bracketed annotations, jinka effect har attribute ke rules se specify hota hai. Kuch diagnostics guide karte hain; kuch semantic contracts assert karte hain. Standard attributes ignore karne se correct program ke semantics nahi badalte, lekin false asserted property undefined behavior cause kar sakti hai. - Chhoti conveniences — binary literals (
0b101010), readability ke liye digit separators (1'000'000), aur#embedjo kisi binary file ke contents ko directly source code mein pull karta hai. - Doosri type facilities: Supported declaration forms mein
autoinitializer se object ka type infer kar sakta hai._Decimal32,_Decimal64aur_Decimal128decimal floating types hain, un implementations par jo yeh conditional feature support karti hain.
Feature support exact compiler, version, target, standard-library implementation aur selected language mode par depend karta hai. C23 facilities use karne se pehle inhe check karein; C17 toolchain C23 syntax accept karegi ya har optional feature exist karega, yeh assume na karein.
Agla idea padhne ke liye tayyar?
Mark this chapter as read whenever you feel ready.