PGDCA, BCA, B-Tech, MCA, M-Tech, B.Sc computer science राजस्थान सूचना सहायक व कंप्यूटर शिक्षक विशेष नोट्स: इस अध्याय में हम Pointer Arithmetic: Addition, Subtraction of Pointers (पॉइंटर अंकगणित: पूर्णांक जोड़ना, घटाना और डेटा टाइप साइज प्रभाव) की संपूर्ण थ्योरी, मुख्य तकनीकी बिंदु, तुलनात्मक तालिका और विगत परीक्षाओं के पैटर्न पर आधारित 20 अति-महत्वपूर्ण बहुविकल्पीय प्रश्न (MCQs) विस्तृत हिंदी व अंग्रेजी व्याख्या सहित पढ़ेंगे।
Overview: Pointer arithmetic in C scales integer additions and subtractions by sizeof(*ptr) so p + k advances k elements, while subtracting two same-type array pointers returns signed element distance ptrdiff_t.
अध्याय सार: C में पॉइंटर अंकगणित में पूर्णांक जोड़ने या घटाने पर पता स्वतः डेटा टाइप के आकार (sizeof(*ptr)) से गुणा होकर आगे बढ़ता है, तथा एक ही एरे के दो पॉइंटर्स का घटाव तत्वों का अंतर (ptrdiff_t) देता है।
Pointer Arithmetic: Addition, Subtraction of Pointers: Detailed Notes & Architecture (पॉइंटर अंकगणित: पूर्णांक जोड़ना, घटाना और डेटा टाइप साइज प्रभाव)
1. Scaled Integer Addition & Subtraction (p + n, p - n) (स्केल्ड पूर्णांक जोड़ व घटाव (p + n, p - n))
[EN] Unlike ordinary integer math, adding or subtracting an integer n to a typed pointer T *p scales automatically by the size of the pointed object: addr(p + n) = addr(p) + n * sizeof(T). For instance, if 4-byte int *p sits at 1000, then p + 3 evaluates to 1012 (NOT 1003), while for 8-byte double *d at 1000, d + 3 yields 1024, and for 1-byte char *c at 1000, c + 3 yields 1003. Increment (p++) and decrement (p--) obey the exact same scaling rule.
[HI] सामान्य गणित के विपरीत, किसी पॉइंटर T *p में पूर्णांक n जोड़ने या घटाने पर मेमोरी पता n * sizeof(T) बाइट्स आगे या पीछे खिसकता है। यदि 4-बाइट int *p का एड्रेस 1000 हो, तो p + 3 करने पर 1003 नहीं बल्कि 1012 प्राप्त होगा; जबकि 8-बाइट double * पर यह 1024 और 1-बाइट char * पर 1003 होगा। p++ और p-- भी इसी स्केल नियम से चलते हैं।
2. Pointer-to-Pointer Subtraction (p2 - p1) & ptrdiff_t (दो पॉइंटर्स का घटाव (p2 - p1) व ptrdiff_t)
[EN] Subtracting two pointers of the same compatible type that point into the SAME array (or one-past-the-end) computes the signed number of elements separating them, NOT raw byte difference: (addr(p2) - addr(p1)) / sizeof(T). The result has signed integer type ptrdiff_t defined in <stddef.h> (printed with %td). Subtracting pointers pointing to two unrelated variables or different arrays triggers Undefined Behavior, and subtracting incompatible pointer types (like int * - char *) is a compile error.
[HI] एक ही एरे की ओर संकेत करने वाले समान टाइप के दो पॉइंटर्स का घटाव (p2 - p1) बाइट अंतर के बजाय उनके बीच के तत्वों की संख्या लौटाता है: (addr(p2) - addr(p1)) / sizeof(T)। इसका डेटा टाइप <stddef.h> का ptrdiff_t होता है। दो अलग-अलग एरे या असमान टाइप के पॉइंटर्स को घटाना अवैध/अनडिफाइंड है।
3. Illegal Pointer Operations & void * Arithmetic Trap (अवैध पॉइंटर संक्रियाएँ व void * अंकगणित नियम)
[EN] ISO C strictly prohibits arithmetic operations that produce meaningless addresses: adding two pointers (p1 + p2), multiplying pointers (p1 * 2 or p1 * p2), dividing pointers (p1 / 2), modulo (p1 % 2), and bitwise shifts/masks on pointers are all compile-time errors. Moreover, in standard ISO C, arithmetic on 'void *' (such as vp + 1 or vp++) is illegal because sizeof(void) is undefined—though GCC offers a non-standard extension treating sizeof(void) as 1 byte (warned under -Wpointer-arith).
[HI] दो पॉइंटर्स को जोड़ना (p1 + p2), किसी पॉइंटर का गुणा (p1 * 2), भाग (p1 / 2), मॉड्यूलो या बिटवाइज ऑपरेशन करना C में पूरी तरह अवैध (कम्पाइल एरर) है। मानक ISO C में 'void *' पर भी अंकगणित (vp++) अवैध है क्योंकि void का आकार परिभाषित नहीं है (यद्यपि GCC में गैर-मानक एक्सटेंशन से 1 बाइट माना जाता है)।
4. Precedence Traps (*p++, (*p)++, *++p) & Relational Bounds (प्रिसिडेंस जाल (*p++, (*p)++, *++p) व तुलना नियम)
[EN] Dereference (*) and postfix/prefix ++/-- have high precedence, but postfix ++ binds tighter than unary *, while prefix ++ and * have equal precedence with RIGHT-TO-LEFT associativity! Thus: '*p++' equals '*(p++)' (reads current *p, then increments pointer p); '(*p)++' increments the target integer value itself; '*++p' increments p first, then dereferences the new slot; '++*p' equals '++(*p)' (pre-increments target value). Forming the one-past-end pointer &arr[N] for loop bounds (<, !=) is legal, though dereferencing it is UB.
[HI] पोस्टफिक्स ++ की प्राथमिकता * से अधिक है, और प्रीफिक्स ++ व * की प्राथमिकता बराबर (दाएँ-से-बाएँ साहचर्य) होती है: '*p++' वर्तमान मान पढ़कर पॉइंटर p को आगे बढ़ाता है; '(*p)++' उस पते पर रखे मान को बढ़ाता है; '*++p' पहले पॉइंटर बढ़ाकर नया मान पढ़ता है; और '++*p' लक्षित मान को प्री-इंक्रीमेंट करता है। एरे के अंत से एक आगे (&arr[N]) तक तुलना (<, !=) वैध है पर उसे डिरेफरेंस करना UB है।
Syntax, Formula & Technical Example (Pointer Arithmetic: Addition, Subtraction of Pointers)
#include <stdio.h>
#include <stddef.h>
int main(void) {
int arr[] = {10, 20, 30, 40};
int *p = arr, *q = &arr[3];
ptrdiff_t gap = q - p; // 3 elements (12 bytes / 4 bytes)
printf("*p++=%d ", *p++); // Prints 10, then p points to arr[1] (20)
printf("(*p)++=%d ", (*p)++); // Prints 20, then arr[1] becomes 21
printf("gap=%td arr[1]=%d\n", gap, arr[1]);
return 0;
}
Pointer Arithmetic: Addition, Subtraction of Pointers Quick Reference & Comparison Table
| Pointer Expression | Exact C Effect | Exam Critical Fact |
|---|---|---|
| p + k (Pointer + Integer) | Advances address by k * sizeof(*p) bytes | Scales automatically by pointed type size |
| p2 - p1 (Same-Array Sub) | Returns signed ptrdiff_t element count | Equals byte difference divided by sizeof(*p) |
| p1 + p2 (Pointer + Pointer) | Compile-time syntax error (illegal) | Multiplication, division, modulo also illegal |
| *p++ vs (*p)++ | *p++ shifts pointer; (*p)++ mutates target value | Postfix ++ binds tighter than unary * |
Pointer Arithmetic: Addition, Subtraction of Pointers Top 20 Bilingual MCQs with Answers
Q1. Suppose 'double *p = (double *)2000;' on a system where sizeof(double) = 8. What address does 'p + 4' compute?
(यदि 'double *p = (double *)2000;' हो और sizeof(double) = 8 बाइट हो, तो 'p + 4' कौन सा एड्रेस देगा?)
(A) 2004
(B) 2064
(C) 2032
(D) 2016
Correct Answer: (C)
[EN] Pointer addition scales by sizeof(double): 2000 + 4 * 8 = 2032.
[HI] पॉइंटर जोड़ में पूर्णांक 4 का गुणा sizeof(double) यानी 8 से होगा: 2000 + 32 = 2032।
Q2. Given 'int arr[5] = {1,2,3,4,5}; int *p = &arr[1]; int *q = &arr[4];' with 4-byte ints, what is 'q - p'?
(4-बाइट int वाले एरे में 'p = &arr[1]' और 'q = &arr[4]' हो, तो 'q - p' का मान क्या होगा?)
(A) 3
(B) 4
(C) Compile error
(D) 12
Correct Answer: (A)
[EN] Subtracting two pointers into the same array yields element distance (4 - 1 = 3 elements), NOT raw byte difference (12).
[HI] समान एरे के दो पॉइंटर्स घटाने पर बाइट अंतर (12) नहीं बल्कि तत्वों की दूरी (4 - 1 = 3) मिलती है।
Q3. Which arithmetic operation on pointers p1 and p2 (both int *) is completely ILLEGAL in C?
(दो पॉइंटर्स p1 और p2 (दोनों int *) पर इनमें से कौन सी संक्रिया C में पूरी तरह अवैध (Compile Error) है?)
(A) p1 + 3
(B) p1 + p2
(C) p1 - p2
(D) p1 > p2
Correct Answer: (B)
[EN] Adding, multiplying, dividing, or taking modulo between two pointers is prohibited in C because adding two memory addresses has no meaning.
[HI] दो मेमोरी एड्रेस को आपस में जोड़ना (p1 + p2), गुणा या भाग करना C में कम्पाइल एरर देता है।
Q4. In 'int a[] = {10, 20, 30}; int *p = a; printf("%d ", *p++); printf("%d", *p);', what is the output?
(कोड: int a[] = {10, 20, 30}; int *p = a; printf("%d ", *p++); printf("%d", *p); का आउटपुट क्या होगा?)
(A) 11 11
(B) 10 11
(C) 20 20
(D) 10 20
Correct Answer: (D)
[EN] Postfix ++ binds tighter than *, so *p++ returns old *p (10) and advances pointer p to a[1]; next *p prints 20.
[HI] *p++ पहले वर्तमान मान 10 लौटाकर पॉइंटर p को अगले तत्व a[1] पर ले जाता है, अतः अगला *p मान 20 प्रिंट करेगा।
Q5. In 'int a[] = {10, 20, 30}; int *p = a; printf("%d ", (*p)++); printf("%d", a[0]);', what is the output?
(कोड: int a[] = {10, 20, 30}; int *p = a; printf("%d ", (*p)++); printf("%d", a[0]); का आउटपुट क्या होगा?)
(A) 10 20
(B) 10 11
(C) 11 11
(D) 20 20
Correct Answer: (B)
[EN] Parentheses force dereference first; (*p)++ returns old value of a[0] (10) and increments a[0] in place to 11.
[HI] कोष्ठक होने से (*p)++ पहले a[0] का पुराना मान 10 प्रिंट कर देता है और फिर a[0] को बढ़ाकर 11 कर देता है।
Q6. In 'int a[] = {10, 20, 30}; int *p = a; printf("%d", *++p);', what is printed?
(कोड: int a[] = {10, 20, 30}; int *p = a; printf("%d", *++p); से क्या प्रिंट होगा?)
(A) 30
(B) 20
(C) 10
(D) 11
Correct Answer: (B)
[EN] Unary * and prefix ++ associate right-to-left: ++p moves p to a[1] first, then * dereferences a[1] (20).
[HI] प्रीफिक्स ++ और * दाएँ-से-बाएँ चलते हैं: पहले ++p से पॉइंटर a[1] पर जाता है, फिर * से 20 प्रिंट होता है।
Q7. In 'int a[] = {10, 20, 30}; int *p = a; printf("%d", ++*p);', what is printed?
(कोड: int a[] = {10, 20, 30}; int *p = a; printf("%d", ++*p); से क्या प्रिंट होगा?)
(A) 10
(B) 11
(C) 20
(D) Compile error
Correct Answer: (B)
[EN] Right-to-left associativity parses ++*p as ++(*p), incrementing a[0] from 10 to 11 before printing.
[HI] दाएँ-से-बाएँ साहचर्य के कारण ++*p का अर्थ ++(*p) होता है, जो a[0] को 10 से 11 करके प्रिंट करता है।
Q8. What signed standard library type represents the result of subtracting two pointers (p2 - p1)?
(दो पॉइंटर्स के घटाव (p2 - p1) के परिणाम को दर्शाने के लिए <stddef.h> में कौन सा डेटा टाइप परिभाषित है?)
(A) uintptr_t
(B) intptr_t
(C) size_t
(D) ptrdiff_t
Correct Answer: (D)
[EN] <stddef.h> defines ptrdiff_t as the signed integer type for pointer differences (whereas size_t is unsigned).
[HI] <stddef.h> में ptrdiff_t साइन्ड पूर्णांक टाइप के रूप में पॉइंटर अंतर रखने के लिए परिभाषित है।
Q9. What happens when compiling 'void *vp = arr; vp++;' under strict standard ISO C (-pedantic-errors)?
(मानक ISO C (-pedantic-errors) में 'void *vp = arr; vp++;' कम्पाइल करने पर क्या होता है?)
(A) Error: ISO C forbids arithmetic on void * pointers because void has no size
(B) vp advances by 8 bytes
(C) vp advances by 4 bytes
(D) vp becomes NULL
Correct Answer: (A)
[EN] Standard C forbids void * arithmetic since sizeof(void) is undefined (only a non-standard GCC extension assumes 1 byte).
[HI] मानक ISO C में void का आकार न होने के कारण void * पर जोड़-घटाव (vp++) अवैध है।
Q10. Consider 'char *cp = (char *)5000; float *fp = (float *)5000;' where sizeof(float) = 4. After 'cp += 2; fp += 2;', what are cp and fp?
(यदि cp (char *) और fp (float *, 4 बाइट) दोनों 5000 पर हों, तो 'cp += 2; fp += 2;' के बाद उनके मान क्या होंगे?)
(A) cp = 5002 and fp = 5008
(B) cp = 5001 and fp = 5004
(C) cp = 5002 and fp = 5002
(D) cp = 5008 and fp = 5008
Correct Answer: (A)
[EN] cp increments by 2 * 1 = 2 bytes, while fp increments by 2 * 4 = 8 bytes.
[HI] char साइज 1 बाइट होने से cp = 5002 होगा, जबकि float साइज 4 बाइट होने से fp = 5008 होगा।
Q11. What happens if you subtract an 'int *p' and a 'char *q' pointing into memory using 'p - q'?
(यदि एक 'int *p' और एक 'char *q' को 'p - q' से घटाने का प्रयास किया जाए तो क्या होगा?)
(A) Returns 0 always
(B) Automatically casts char * to int *
(C) Returns difference in bytes
(D) Compile-time error: invalid operands to binary - (incompatible pointer types)
Correct Answer: (D)
[EN] C allows pointer subtraction ONLY between pointers to compatible object types.
[HI] पॉइंटर घटाव केवल समान (Compatible) डेटा टाइप वाले पॉइंटर्स के बीच ही वैध है, अन्यथा कम्पाइल एरर आता है।
Q12. In C, what is the rule regarding the 'one-past-the-end' pointer (&arr[N]) for an array int arr[N]?
(N आकार के एरे int arr[N] के लिए अंतिम तत्व से ठीक अगले पते (&arr[N]) के बारे में C का क्या नियम है?)
(A) Both forming and dereferencing &arr[N] are valid
(B) Forming and comparing (&arr[N]) is valid, but dereferencing *(&arr[N]) is Undefined Behavior
(C) Even forming &arr[N] causes immediate Segmentation Fault
(D) &arr[N] automatically points back to arr[0]
Correct Answer: (B)
[EN] C guarantees you can compute and compare the sentinel pointer one element past the end (used in loops like p < arr + N) without UB.
[HI] लूप की सीमा (p < arr + N) जांचने के लिए &arr[N] बनाना व तुलना करना वैध है, पर उस पर * लगाकर मान पढ़ना अनडिफाइंड है।
Q13. What happens when comparing pointers using '<' (e.g., if (p1 < p2)) when both point into the same array?
(जब दो पॉइंटर p1 व p2 एक ही एरे के तत्वों की ओर संकेत करें, तो 'if (p1 < p2)' तुलना का क्या परिणाम होता है?)
(A) Always evaluates to True
(B) True (1) if p1 points to an earlier element (lower index) than p2, else False (0)
(C) Compile-time error because relational operators forbid pointers
(D) Compares pointed values *p1 < *p2
Correct Answer: (B)
[EN] Relational comparisons (<, <=, >, >=) on pointers within the same array safely order their relative array indices.
[HI] एक ही एरे में <, > तुलनाएं दोनों पॉइंटर्स के पते (अर्थात छोटे या बड़े इंडेक्स) की सही तुलना करती हैं।
Q14. What does '(char *)(&arr[3]) - (char *)(&arr[1])' evaluate to for 'int arr[5];' with 4-byte ints?
(4-बाइट int वाले एरे 'int arr[5];' के लिए '(char *)(&arr[3]) - (char *)(&arr[1])' का मान क्या होगा?)
(A) 4
(B) 8
(C) 12
(D) 2
Correct Answer: (B)
[EN] Casting both pointers to char * (1-byte scale) computes the raw byte offset between arr[3] and arr[1]: 2 * 4 = 8 bytes.
[HI] दोनों को char * (1-बाइट स्केल) में बदलने से घटाव तत्व संख्या (2) के बजाय वास्तविक बाइट अंतर (8) लौटाएगा।
Q15. Which statement is NOT true about Pointer Arithmetic in C?
(C में पॉइंटर अंकगणित के बारे में इनमें से कौन सा कथन असत्य है?)
(A) Adding integer k to T *p advances the address by k * sizeof(T) bytes
(B) *p++ increments the pointer p, not the value pointed to
(C) Subtracting two int * pointers in the same array returns the exact byte distance between them
(D) Multiplying a pointer by 2 is a compile-time error
Correct Answer: (C)
[EN] Subtracting two int * pointers divides the byte distance by sizeof(int) and returns the count of int elements, NOT raw bytes.
[HI] दो int * पॉइंटर्स को घटाने पर कुल बाइट दूरी नहीं, बल्कि sizeof(int) से भाग होकर तत्वों की संख्या प्राप्त होती है।
Q16. Why does 'arr++' fail to compile for 'int arr[5];' while 'p++' succeeds for 'int *p = arr;'?
('int arr[5];' के लिए 'arr++' कम्पाइल एरर क्यों देता है जबकि 'int *p = arr;' के लिए 'p++' सही चलता है?)
(A) arr has size 20 so ++ overflows
(B) arr is a fixed array name (non-modifiable lvalue), whereas p is a separate modifiable pointer variable
(C) ++ only works on global arrays
(D) arr points to read-only memory
Correct Answer: (B)
[EN] An array identifier represents a fixed block location whose address cannot be reassigned, unlike a pointer variable p.
[HI] एरे का नाम एक अचल मेमोरी ब्लॉक को दर्शाता है जिसे बदला नहीं जा सकता, जबकि p एक परिवर्तनशील पॉइंटर वेरिएबल है।
Q17. Within Pointer Arithmetic: Addition, Subtraction of Pointers, which pointer expression directly maps to: "Advances address by k * sizeof(*p) bytes"?
(Pointer Arithmetic: Addition, Subtraction of Pointers में कौन सा Pointer Expression सीधे "Advances address by k * sizeof(*p) bytes" से संबंधित है?)
(A) *p++ vs (*p)++
(B) p2 - p1 (Same-Array Sub)
(C) p1 + p2 (Pointer + Pointer)
(D) p + k (Pointer + Integer)
Correct Answer: (D)
[EN] In Pointer Arithmetic: Addition, Subtraction of Pointers, 'p + k (Pointer + Integer)' handles 'Advances address by k * sizeof(*p) bytes' (Scales automatically by pointed type size).
[HI] Pointer Arithmetic: Addition, Subtraction of Pointers में 'p + k (Pointer + Integer)' का कार्य/विवरण 'Advances address by k * sizeof(*p) bytes' (Scales automatically by pointed type size) है।
Q18. Which option accurately describes 'p2 - p1 (Same-Array Sub)' in Pointer Arithmetic: Addition, Subtraction of Pointers?
(Pointer Arithmetic: Addition, Subtraction of Pointers के संदर्भ में 'p2 - p1 (Same-Array Sub)' की सही विशेषता कौन सी है?)
(A) Compile-time syntax error (illegal)
(B) Advances address by k * sizeof(*p) bytes
(C) *p++ shifts pointer; (*p)++ mutates target value
(D) Returns signed ptrdiff_t element count
Correct Answer: (D)
[EN] 'p2 - p1 (Same-Array Sub)' provides 'Returns signed ptrdiff_t element count' — key point: Equals byte difference divided by sizeof(*p).
[HI] 'p2 - p1 (Same-Array Sub)' का मुख्य विवरण 'Returns signed ptrdiff_t element count' है (Equals byte difference divided by sizeof(*p))।
Q19. In Pointer Arithmetic: Addition, Subtraction of Pointers, identify the correct parameter for the specification: "Compile-time syntax error (illegal)".
(Pointer Arithmetic: Addition, Subtraction of Pointers में "Compile-time syntax error (illegal)" विवरण किस विकल्प के लिए सही है?)
(A) p2 - p1 (Same-Array Sub)
(B) p1 + p2 (Pointer + Pointer)
(C) p + k (Pointer + Integer)
(D) *p++ vs (*p)++
Correct Answer: (B)
[EN] 'p1 + p2 (Pointer + Pointer)' corresponds to 'Compile-time syntax error (illegal)' (Multiplication, division, modulo also illegal).
[HI] 'p1 + p2 (Pointer + Pointer)' का संबंध 'Compile-time syntax error (illegal)' (Multiplication, division, modulo also illegal) से है।
Q20. Considering Pointer Arithmetic: Addition, Subtraction of Pointers, what key behavior defines '*p++ vs (*p)++'?
(Pointer Arithmetic: Addition, Subtraction of Pointers में '*p++ vs (*p)++' की मुख्य भूमिका या मान क्या है?)
(A) *p++ shifts pointer; (*p)++ mutates target value
(B) Advances address by k * sizeof(*p) bytes
(C) Compile-time syntax error (illegal)
(D) Returns signed ptrdiff_t element count
Correct Answer: (A)
[EN] '*p++ vs (*p)++' represents '*p++ shifts pointer; (*p)++ mutates target value' (Postfix ++ binds tighter than unary *).
[HI] '*p++ vs (*p)++' का अर्थ/मान '*p++ shifts pointer; (*p)++ mutates target value' है (Postfix ++ binds tighter than unary *)।
Pointer Arithmetic: Addition, Subtraction of Pointers — Exam FAQs
Q1: Why did C designers make p2 - p1 return element count instead of byte difference?
C के निर्माताओं ने p2 - p1 में बाइट अंतर के बजाय तत्वों की संख्या लौटाने का नियम क्यों बनाया?
[EN] Because pointer addition is symmetric with subtraction: if q = p + k advances k elements, then q - p must logically equal k so index arithmetic stays type-safe and portable across 2-byte, 4-byte, and 8-byte architectures.
[HI] क्योंकि यदि q = p + k करने पर पॉइंटर k तत्व आगे बढ़ता है, तो समरूपता के लिए q - p का मान भी k ही होना चाहिए ताकि कोड हर डेटा साइज के कंप्यूटर पर एक जैसा चले।
Q2: Can we perform bitwise operations like p & 1 to check pointer alignment in C?
क्या पॉइंटर एलाइनमेंट जांचने के लिए सीधे p & 1 जैसा बिटवाइज ऑपरेशन कर सकते हैं?
[EN] Not directly on pointer types (bitwise & on pointers is illegal). First cast the pointer to uintptr_t from <stdint.h> (e.g., ((uintptr_t)p & 0x7) == 0) to inspect alignment portably.
[HI] सीधे पॉइंटर पर बिटवाइज & अवैध है। पहले <stdint.h> के uintptr_t में टाइपकास्ट करके ((uintptr_t)p & 0x7) से एलाइनमेंट जांचा जा सकता है।
Q3: Is pointer subtraction allowed between two pointers pointing to two separate local variables int a, b;?
क्या दो अलग-अलग लोकल वेरिएबल int a, b; के पॉइंटर्स (&a - &b) को घटाना वैध है?
[EN] No! ISO C classifies subtracting pointers to different non-array objects as Undefined Behavior because compilers assume pointers in subtraction belong to the same array object during optimization.
[HI] नहीं! मानक C के अनुसार अलग-अलग वेरिएबल्स या अलग एरे के पॉइंटर्स को घटाना अनडिफाइंड बिहेवियर (Undefined Behavior) है।
Post a Comment
Post a Comment