🎹 👲 🈺 C ++ में अपरिभाषित व्यवहार ⛓️ 🐛 📮

C ++ प्रोग्रामर के लिए एक काफी जटिल विषय अपरिभाषित व्यवहार है। यहां तक कि अनुभवी डेवलपर्स अक्सर इसकी घटना के कारणों को स्पष्ट नहीं कर सकते हैं। लेख में इस मुद्दे पर थोड़ी और स्पष्टता लाने का इरादा है।

लेख इस विषय पर मानक से कई लेखों और अर्क का अनुवाद है।

"अंक का पालन करें" क्या हैं?

मानक कहते हैं:

अनुक्रम अंक (अनुक्रम अंक) - कार्यक्रम निष्पादन की प्रक्रिया में ऐसे बिंदु, जिसमें पहले से निष्पादित कोड के सभी दुष्प्रभाव समाप्त हो गए हैं, और निष्पादित किए जाने वाले कोड के दुष्प्रभाव अभी तक कार्य करना शुरू नहीं हुए हैं। (§1.9 / 7)

साइड इफेक्ट्स? "दुष्प्रभाव" क्या हैं?

एक पक्ष प्रभाव (मानक के अनुसार) एक अस्थिर वस्तु तक पहुंचने, वस्तु को बदलने, आई / ओ लाइब्रेरी से एक फ़ंक्शन को कॉल करने या एक फ़ंक्शन को कॉल करने का परिणाम है, जिसमें इनमें से कुछ क्रियाएं शामिल हैं। एक साइड इफेक्ट रनटाइम की स्थिति में बदलाव है।

कुछ अभिव्यक्ति की गणना कुछ प्रकार का आउटपुट देती है। यदि, परिणाम के अलावा, अभिव्यक्ति का मूल्यांकन करने से रनटाइम में परिवर्तन होता है, तो यह कहा जाता है कि अभिव्यक्ति के दुष्प्रभाव हैं।

उदाहरण के लिए:

int x = y++; // «y»  int

चर "x" को शुरू करने के अलावा, ++ ऑपरेटर के साइड इफेक्ट के कारण चर "y" का मूल्य बदल गया है।
खैर, यह स्पष्ट है। उत्तराधिकार के बिंदुओं के आगे। स्टीव पास ("प्रश्न और उत्तर में भाषा सी", ब्लॉग "comp.lang.c") पुस्तकों के लेखक द्वारा "पास के बिंदु" शब्द की एक वैकल्पिक परिभाषा दी गई थी:
फॉलो- अप बिंदु उस समय का बिंदु है जब "डस्ट सेटल" होता है, और सामने आने वाले सभी साइड इफेक्ट्स को पूरा करने और पीछे छोड़ने की गारंटी होती है।

C ++ मानक में निम्नलिखित बिंदुओं का वर्णन किया गया है?

निम्नलिखित अनुक्रम बिंदु मानक में वर्णित हैं:

पूर्ण अभिव्यक्ति की गणना के अंत में (/1.9 / 16)। "पूर्ण-अभिव्यक्ति" से अभिप्राय एक ऐसी अभिव्यक्ति से है जो एक उप-एक्सप्रेशन नहीं है - एक अन्य एक्सप्रेशन का भाग (नोट: एक संपूर्ण अभिव्यक्ति का मूल्यांकन करने में एक सब-एक्सप्रेशन का मूल्यांकन करना शामिल हो सकता है जो कि इसका शाब्दिक हिस्सा नहीं है। उदाहरण के लिए, तर्क का मूल्यांकन करने में शामिल उप-एक्सप्रेशन। डिफ़ॉल्ट रूप से, उस अभिव्यक्ति का हिस्सा माना जाता है जिसे फ़ंक्शन कहा जाता है, न कि इस तर्क को परिभाषित करने वाली अभिव्यक्ति)।

उदाहरण के लिए:
```
 int a = 5; // «;» -      
```
पहले ऑपरेंड की गणना के बाद, अर्थात् निम्नलिखित भावों की गणना करने में:

1. a && b (§5.14)
2. ए || b ((5.15)
3. ए? बी: सी (:5.16)
4. ए, बी (§5.18)

इन भावों की गणना बाएं से दाएं जाती है। बाईं उपपरिवर्तन की गणना करने के बाद, इस संगणना के सभी दुष्प्रभाव मौजूद हैं। यदि, बाईं उपसंचाई की गणना करने के बाद, पूर्ण अभिव्यक्ति का मूल्य ज्ञात होता है, तो सही पक्ष की गणना नहीं की जाती है। उत्तरार्द्ध मामले में, ऑपरेटर एक अल्पविराम है। फंक (ए, ए ++) फ़ंक्शन में, कॉमा एक ऑपरेटर नहीं है, लेकिन तर्कों के बीच बस एक विभाजक है।
किसी फ़ंक्शन को कॉल करते समय (यह महत्वपूर्ण नहीं है कि फ़ंक्शन उसके सभी तर्कों (यदि कोई हो) की गणना करने के बाद या उसके शरीर में किसी भी निर्देश को निष्पादित करने से पहले बनाया गया है या नहीं)।

"अनिश्चित व्यवहार" क्या है?

मानक :1.3.12 में "अनिश्चित व्यवहार" वाक्यांश को परिभाषित करता है:

अपरिभाषित व्यवहार - गलत सॉफ्टवेयर निर्माण या गलत डेटा के उपयोग के परिणामस्वरूप होने वाला व्यवहार, जिसके लिए अंतर्राष्ट्रीय मानक किसी भी आवश्यकता को लागू नहीं करता है। मानक में स्पष्ट रूप से वर्णित स्थितियों में अपरिभाषित व्यवहार भी हो सकता है।

दूसरे शब्दों में, अनिश्चित व्यवहार का मतलब कुछ भी हो सकता है, जो एक बूगर से शुरू होकर नाक से गिरना और अपनी प्रेमिका की गर्भावस्था के साथ समाप्त होता है।

अनिश्चित व्यवहार और अनुक्रम बिंदुओं के बीच क्या संबंध है?

इस प्रश्न का उत्तर जानने से पहले, आपको अपरिभाषित व्यवहार, अनिर्दिष्ट व्यवहार और कार्यान्वयन-परिभाषित व्यवहार के बीच के अंतरों को समझने की आवश्यकता है।

अनिर्दिष्ट व्यवहार (मानक के अनुसार) - वह व्यवहार जिसके लिए मानक दो या दो से अधिक संभावित विकल्प प्रदान करता है और स्पष्ट आवश्यकताओं को लागू नहीं करता है, जिस पर किसी विशेष स्थिति में चयन किया जाना चाहिए।

अनिर्दिष्ट व्यवहार के परिणाम जैसे कि सबसक्सेसियन की गणना:

फ़ंक्शन कॉल में तर्क
ऑपरेटरों के संचालन (जैसे +, -, =, *, /), के अपवाद के साथ:
1. बाइनरी लॉजिक ऑपरेटर (&& और ||)
2. हालत बयान (:)
3. अल्पविराम ऑपरेटर।
(ध्यान दें: उन ऑपरेटरों के अपवाद के साथ जिनमें अनुक्रम शामिल है)

क्रियान्वयन -परिभाषित व्यवहार (मानक के अनुसार) सही डेटा के साथ एक अच्छी तरह से गठित सॉफ्टवेयर निर्माण का व्यवहार है, जो कार्यान्वयन पर निर्भर करता है (प्रत्येक कार्यान्वयन के लिए दस्तावेज होना चाहिए)।

इस व्यवहार का एक उदाहरण सूचक का आकार है। मानक के अनुसार, सूचक का आकार संकलक के विशिष्ट कार्यान्वयन पर निर्भर करता है। एक विशेष कार्यान्वयन में, विभिन्न प्रकार के संकेत के आकार भी भिन्न हो सकते हैं।
मैं यह भी नोट करना चाहता हूं कि किसी विशेष ऑपरेटर के ऑपरेंड की गणना करने की प्रक्रिया, एक विशिष्ट अभिव्यक्ति के सबएक्सप्रेस, और साइड इफेक्ट होने का क्रम निर्दिष्ट नहीं है।

उदाहरण के लिए:

 int x = 5, y = 6; int z = x++ + y++; //  ,    x++  y++

एक और उदाहरण:

 int Hello() { return printf("Hello"); } int World() { return printf("World !"); } int main() { int a = Hello() + World(); /**  «Hello World!»  «World! Hello» ^ |        **/ return 0; }

In5 / 4 में, मानक कहता है:

उत्तराधिकार के दो बिंदुओं के बीच, स्केलर ऑब्जेक्ट को एक से अधिक बार अभिव्यक्ति की गणना करते समय संग्रहीत मूल्य को बदलना होगा।

इसका क्या मतलब है?

सीधे शब्दों में कहें, दो उत्तराधिकार बिंदुओं के बीच एक चर को एक से अधिक बार नहीं बदला जा सकता है। एक अभिव्यक्ति में, अगला अनुक्रम बिंदु आमतौर पर समापन अर्धविराम पर स्थित होता है, और पिछले कथन के अंत में पिछला होता है। एक अभिव्यक्ति में मध्यवर्ती अनुक्रम बिंदु भी हो सकते हैं।
पूर्वगामी के आधार पर, निम्न अभिव्यक्तियाँ अपरिभाषित व्यवहार बनाती हैं:

 i++ * ++i; // i = ++i; // ++i = 2; // i   1  i = ++i +1 // i = (i,++i,++i); //      `++i`   `i` (`i`   1   2  )

लेकिन एक ही समय में:

 i = (i, ++i, 1) + 1; //  i = (++i,i++,i) //  int j = i; j = (++i, i++, j*i); //

इसके अलावा (मानक के अनुसार) - अभिव्यक्ति का पुराना मूल्य (गणना से पहले) केवल संग्रहीत मूल्य का निर्धारण करने के लिए उपलब्ध होना चाहिए।
इसका मतलब यह है कि जिन भावों में मूल्य का उपयोग किया गया है, वे इसके संशोधन से पहले हो सकते हैं।

उदाहरण के लिए:

 std::printf("%d %d", i,++i); // ,    –  (++i)    .

एक और उदाहरण:

 a[i] = i++ ; //  a[++i] = i ,  a[i++] = ++i  ..

मैंने सुना है कि C ++ 0x में कोई फॉलो पॉइंट नहीं हैं, क्या यह सच है?

हाँ यह सच है।
एक "अनुवर्ती बिंदु" की अवधारणा को आईएसओ सी ++ समिति द्वारा एक अनुवर्ती रिश्ते [पहले से बेहतर] की परिष्कृत और संवर्धित अवधारणा के साथ बदल दिया गया था।

अनुवर्ती संबंध [पहले] क्या है?

इससे पहले कि एक रिश्ता है:
विषम
सकर्मक
संगणना के जोड़े और आंशिक रूप से क्रमबद्ध सेट के बीच से उत्पन्न होता है

औपचारिक रूप से, इसका मतलब यह है कि दो दिए गए ए और बी के लिए, यदि ए [डीओ] बी का अनुसरण करता है, तो ए को निष्पादन पूर्व करना चाहिए बी। ए ए को डीओ का पालन नहीं करता है] बी, तो ए और बी का निष्पादन अप्रयुक्त है। (अनियंत्रित गणना ओवरलैप हो सकती है)।
ए और बी की गणना अनिश्चित रूप से अनुक्रमित होती है जब ए [डीओ] बी या बी [डीओ का अनुसरण करता है] ए, लेकिन क्या वास्तव में निर्दिष्ट नहीं है। अनिश्चित रूप से आदेशित गणनाएं प्रतिच्छेद नहीं कर सकती हैं, लेकिन उनमें से किसी को भी पहले निष्पादित किया जा सकता है।

C ++ 0x के संदर्भ में "गणना" शब्द का क्या अर्थ है?

C ++ 0x में, एक अभिव्यक्ति का मूल्यांकन करना (या उपप्रकार) आम तौर पर शामिल हैं:

मूल्य की गणना (गणना) (जिसमें अंतराल अभिव्यक्ति के मूल्य की गणना करने के लिए स्मृति में किसी वस्तु की स्थिति का निर्धारण करना और मूल्य की अभिव्यक्ति की गणना करने के लिए संदर्भ द्वारा मूल्य प्राप्त करना शामिल है)
साइड इफेक्ट्स की दीक्षा

मानक हमें बताता है (.91.9 / 14):

पूर्ण अभिव्यक्ति के साथ जुड़े प्रत्येक मूल्य गणना और साइड इफेक्ट [आगे का पालन करें] मूल्य गणना और अगली पूर्ण अभिव्यक्ति के साथ जुड़े साइड इफेक्ट की गणना की जानी है।

तुच्छ उदाहरण:

 int x; x = 10; ++x;

इस उदाहरण में, मूल्य की गणना और अभिव्यक्ति के साथ जुड़े साइड इफेक्ट (++ x), [अनुसरण करता है] मूल्य और साइड इफेक्ट की गणना (x = 10)।

आखिरकार, ऊपर वर्णित चीजों और अनिश्चित व्यवहार के बीच किसी तरह का संबंध होना चाहिए, है ना?

बेशक, एक कनेक्शन है।

§1.9 / 15 में यह उल्लेख किया गया है कि:

किसी विशेष संचालक या किसी विशेष अभिव्यक्ति के उप-वर्ग के परिचालनों की गणना अव्यवस्थित है, जैसा कि पहले वर्णित है।

नोट: एक पूर्ण अभिव्यक्ति के अनियंत्रित और अस्पष्ट रूप से ऑर्डर किए गए सबएक्सप्रेस का एक प्रोग्राम के दौरान एक से अधिक बार मूल्यांकन किया जाता है जरूरी नहीं कि प्रत्येक बार उसी क्रम में गणना की जाए।

उदाहरण के लिए:

 int main() { int num = 19 ; num = (num << 3) + (num >> 3) ; }

1) "+" ऑपरेटर के ऑपरेंड की गणना अव्यवस्थित है।
2) ऑपरेटरों के संचालन की गणना "<<" और ">>" अव्यवस्थित है।

Follows1.9 / 15 एक विशिष्ट ऑपरेटर के संचालकों के मूल्य की गणना [संचालक के परिणाम के मूल्य की] इस प्रकार है।

इसका मतलब यह है कि एक्स + वाई की अभिव्यक्ति में, "x" और "y" के मूल्यों की गणना [पहले से] x + y की गणना का अनुसरण करती है।

अब और अधिक महत्वपूर्ण:

§1.9 / 15 यदि किसी स्केलर ऑब्जेक्ट के साइड इफेक्ट की घटना निम्न में से किसी एक घटना के संबंध में होती है:
एक ही वस्तु के दूसरे पक्ष प्रभाव की घटना
इस ऑब्जेक्ट के मूल्य का उपयोग करके एक मूल्य गिनना

फिर कार्यक्रम का व्यवहार UNCERTAINTY होगा।

एक उदाहरण:

 f(i = -1, i = -1);

आइए हम इस अभिव्यक्ति की व्याख्या करें। पहली नज़र में, फ़ंक्शन तर्कों की अव्यवस्थित गणना अस्पष्टता नहीं लाएगी। हालांकि, इस बात की कोई सटीक संभावना नहीं है कि संकलक, इस तरह की अभिव्यक्ति का अनुकूलन करते हुए, कार्रवाई के समान निर्देशों का एक सेट नहीं बनाएगा (इसकी राय में), जो उसी मेमोरी पर संचालन के दौरान विफल हो जाएगा।

मान लीजिए कि संकलक ने फैसला किया कि "-1" को असाइन करने का सबसे अच्छा तरीका चर को शून्य करना और इसे कम करना होगा।
निर्देश निम्नानुसार बनाए जा सकते हैं (आदेश सशर्त हैं):

 clear i decr i clear i decr i

या वे कर सकते हैं:

 clear i clear i decr i decr i

जिसके बाद value -2 को i में स्टोर किया जाएगा।

जब किसी फ़ंक्शन को बुलाया जाता है, तो इस फ़ंक्शन के तर्क की अभिव्यक्ति के साथ या फ़ंक्शन को कॉल करने वाले अभिव्यक्ति के साथ जुड़े मूल्य और साइड इफेक्ट की प्रत्येक गणना, [कहा जाना चाहिए] किसी भी अभिव्यक्ति या ऑपरेटर के फ़ंक्शन के शरीर में निष्पादन।
अलग-अलग तर्कों से जुड़ी मूल्य गणना और साइड इफेक्ट अव्यवस्थित हैं।

कार्यक्रम का प्रवाह

पहले डिक्रिप्ट की गई शर्तों का उपयोग करते हुए, प्रोग्राम निष्पादन प्रवाह को रेखांकन द्वारा दर्शाया जा सकता है। निम्नलिखित आरेखों में, हम एक्स (एक्स) के रूप में अभिव्यक्ति (या उपप्रकार) की गणना को दर्शाते हैं, अनुक्रम बिंदु% है, और वस्तु "ई" के लिए साइड इफेक्ट "ई" एस (के, ई) है। यदि गणना के लिए नामित ऑब्जेक्ट से मान को पढ़ना आवश्यक है ("x" नाम हो), हम शेष मामलों में वी (x) द्वारा गणना को निरूपित करेंगे, शेष मामलों में - E (x) जैसा कि पहले सहमत था। हम भावों के दाईं और बाईं ओर साइड इफेक्ट लिखते हैं। दो अभिव्यक्तियों के बीच की सीमा इंगित करती है कि ऊपरी अभिव्यक्ति निचली अभिव्यक्ति का मूल्यांकन करती है (अक्सर क्योंकि निचली अभिव्यक्ति ऊपरी अभिव्यक्ति के भाव या अंतराल पर निर्भर करती है)।
दो i ++ अभिव्यक्तियों के लिए; मैं ++; आरेख इस तरह दिखेगा:

 E(i++) -> { S(increment, i) } | % | E(i++) -> { S(increment, i) } | %

जैसा कि आप देख सकते हैं, इस मामले में हमारे पास दो निम्नलिखित बिंदु हैं, जिनमें से एक "i" के दो परिवर्तनों को अलग करता है।
फ़ंक्शन कॉल भी रुचि के हैं, हालांकि हम उनके लिए आरेख को छोड़ देते हैं:

 int c = 0; int d = 0; void f(int a, int b) { assert((a == c - 1) && (b == d - 1)); } int main() { f(c++, d++); }

यह कोड सही है, क्योंकि जब तक फ़ंक्शन f का शरीर निष्पादित करना शुरू नहीं करता है, तब तक तर्कों की गणना से उत्पन्न सभी दुष्प्रभाव समाप्त होने की गारंटी दी जाती है: "c" और "d" 1 से बढ़ जाएंगे।
अब अभिव्यक्ति पर विचार करें i ++ * j ++;

 { S(increment, i) } <- E(i++) E(j++) -> { S(increment, j) } \ / +--+--+ | E(i++ * j++) | %

दो शाखाएँ कहाँ से आईं? याद रखें कि अनुक्रम बिंदु गणना पूरी कर लेते हैं कि वे पहले हुए थे। गुणन के सभी उपखंडों की गणना गुणन से पहले ही की जाती है, इस अभिव्यक्ति में अब कोई अनुक्रम बिंदु नहीं है, इसलिए, हमें यह सुझाव देने के लिए संचालकों की गणना के सैद्धांतिक "समानतावाद" को ध्यान में रखना होगा कि जहां एक ही वस्तु का प्रतिस्पर्धी परिवर्तन हो सकता है। अधिक औपचारिक रूप से, ये दो शाखाएं अव्यवस्थित हैं। अनुवर्ती बिंदु एक ऐसा संबंध है जो कुछ गणनाओं का आदेश देता है और दूसरों को आदेश नहीं देता है। इस प्रकार अनुक्रम बिंदु, जैसा कि ऊपर उल्लेख किया गया है, आंशिक आदेश हैं।

संघर्ष के दुष्प्रभाव।

मशीन कोड को उत्पन्न करने और अनुकूलित करने में स्वतंत्रता के साथ संकलक प्रदान करने के लिए, ऊपर विचार किए गए गुणा के समान मामलों में, सबएक्सप्रेस की गणना करने की प्रक्रिया स्थापित नहीं की गई है और उनके द्वारा उत्पन्न साइड इफेक्ट अलग नहीं किए गए हैं (ऊपर वर्णित मामलों को छोड़कर)।
इससे संघर्ष हो सकता है, इसलिए यदि मानक अनुक्रम बिंदुओं की भागीदारी के बिना उसी वस्तु को संशोधित करने की कोशिश करता है, तो मानक कार्यक्रम के व्यवहार को अनिश्चितकालीन कहता है। यह स्केलर ऑब्जेक्ट्स पर लागू होता है, क्योंकि बाकी ऑब्जेक्ट या तो अपरिवर्तनीय (सरणी) होते हैं या बस इस नियम (क्लास साइट्स) के अंतर्गत नहीं आते हैं। अनिर्धारित व्यवहार भी होता है यदि अभिव्यक्ति में ऑब्जेक्ट के पिछले मूल्य और उसके संशोधन के लिए एक कॉल होता है, जैसे कि i * i ++ में

 //    ! //  ,    'i'   «» : V(i) E(i++) -> { S(increment, i) }) \ / +---+---+ | E(i * i++) | %

एक अपवाद के रूप में, किसी वस्तु के मूल्य को पढ़ना संभव है यदि एक नए मूल्य की गणना करना आवश्यक है। प्रसंग उदाहरण: i = i + 1

  V(i) E(1) \ / +---+---+ | E(i) E(i + 1) \ / +-------+-------+ | E(i = i + 1) -> { S(assign, i) } | %

यहां हम दाईं ओर "i" की अपील देखते हैं; दोनों हिस्सों की गणना के बाद, एक असाइनमेंट किया जाता है। इस प्रकार एक साइड इफेक्ट और "आई" के लिए एक कॉल अनुक्रम बिंदु को पार किए बिना होता है, लेकिन हम केवल संग्रहीत मूल्य निर्धारित करने के लिए "i" हो गए, इसलिए कोई असहमति नहीं होगी।
कभी-कभी, मूल्य संशोधन के बाद पढ़ा जाता है। मामले के लिए
a = (b = 0);
यह सच है कि "बी" में एक रिकॉर्ड है, और फिर अनुक्रम बिंदु को पार किए बिना "बी" से पढ़ना है। फिर भी, यह सामान्य है, क्योंकि नया मूल्य "बी" पहले से ही पढ़ा गया है, और पुराने को एक्सेस नहीं किया गया है। इस स्थिति में, असाइनमेंट "बी" के साइड इफेक्ट न केवल अनुक्रम में अगले बिंदु तक समाप्त हो जाएंगे, बल्कि असाइनमेंट "ए" के लिए आवश्यक मूल्य "बी" को पढ़ने से पहले भी। मानक स्पष्ट रूप से कहता है: "असाइनमेंट ऑपरेशन का परिणाम असाइनमेंट पूरा होने के बाद बाएं ऑपरेंड में संग्रहीत मूल्य है (परिणाम लंबित है)।" अनुक्रम बिंदु की अवधारणा का उपयोग क्यों नहीं किया जाता है? क्योंकि इस अवधारणा को पूरा करने के लिए बाएं और दाएं ऑपरेंड के सभी दुष्प्रभावों के लिए इस स्थिति में अनावश्यक आवश्यकता होती है, इसके बजाय केवल उस असाइनमेंट के साइड इफेक्ट्स पर विचार करना है जो उस अंतराल को वापस करता है जिसके साथ रीड होता है।

सूत्रों का कहना है:

C ++ में अपरिभाषित व्यवहार