कांटा न जानने से, पानी में नहीं उतरता। भाग तीन

मैं कहानियों के बारे में जारी रखूंगा कि कैसे प्रोग्रामर इसके बारे में जाने बिना भी किनारे पर घूमते हैं। आइए पारी संचालन के बारे में बात करें <<, >> शिफ्ट ऑपरेटरों के सिद्धांत स्पष्ट हैं और कई प्रोग्रामर को यह भी नहीं पता है कि C / C ++ मानक के अनुसार उनके उपयोग से अपरिभाषित या अनिर्दिष्ट व्यवहार (अनिर्धारित व्यवहार / अनिर्दिष्ट व्यवहार) हो सकता है।


पिछले लेख यहाँ उपलब्ध हैं: [ १ ], [ २ ]।

ऐतिहासिक भ्रमण

शुरुआत में, थोड़ा इतिहास। किसी भी प्रोग्रामर को बिट शिफ्टिंग ऑपरेशन की आवश्यकता स्पष्ट है। जल्दी या बाद में, हर किसी को व्यक्तिगत बिट्स और बिट मास्क के साथ काम करने की आवश्यकता होती है। हालांकि, कतरनी ऑपरेशन बहुत अधिक लोकप्रिय हैं जितना उन्हें होना चाहिए था। कारण यह है कि पारियों का उपयोग करके आप संख्याओं को दो की शक्ति से गुणा और विभाजित कर सकते हैं। उदाहरण के लिए, ऑपरेशन "एक्स << 3" गुणा एक्स द्वारा 8. गुणन और विभाजन की इस पद्धति का लाभ अतीत में उनके काम की गति थी।

अब मैंने एक धूल भरी शेल्फ से प्रोसेसर के लिए कोडांतरक निर्देशों के विवरण के साथ एक किताब ली, जो 8086 से शुरू हुई और 80486 के साथ समाप्त हुई। और मुझे विभिन्न निर्देशों को पूरा करने के लिए आवश्यक घड़ी चक्रों की संख्या पर एक तालिका मिली।

8086 प्रोसेसर पर MUL इंस्ट्रक्शन का उपयोग करके मेमोरी सेल द्वारा 16-बिट रजिस्टर को गुणा करना लगभग 124-139 घड़ी चक्र की आवश्यकता है!

8086 प्रोसेसर पर SHL निर्देश का उपयोग करके N पदों द्वारा 16-बिट रजिस्टर को शिफ्ट करने के लिए 8 + 4 * N चक्र की आवश्यकता होती है। यही है, सबसे खराब स्थिति में, 72 उपाय प्राप्त किए जाते हैं।

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

प्रोसेसर के विकास के साथ, पारियों का उपयोग करने के लाभों को लंबे समय तक बनाए रखा गया है। 80486 प्रोसेसर में, गुणा ने लगभग 26 घड़ी चक्र लिए। यह बहुत बेहतर लगता है। हालांकि, पारी केवल 3 उपाय करने लगी और फिर से गुणा से अधिक आकर्षक थी।

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

नोट। उपरोक्त का मतलब यह नहीं है कि बिट संचालन का उपयोग अब फायदेमंद नहीं हो सकता है। कई रोचक और उपयोगी टोटके हैं [ 3 ]। मुख्य बात इसमें शामिल नहीं होना है।

अपरिभाषित व्यवहार

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

यह पता चला कि प्रोग्रामर पाली के बहुत शौकीन हैं। और उनका उपयोग हर संभव तरीके से किया जाता है, जो अक्सर मानक के दृष्टिकोण से अपरिभाषित व्यवहार के लिए अग्रणी होता है। लेकिन सिद्धांत एक बात है, और अभ्यास एक और है। क्या यह उस कोड पर शपथ लेने का कोई मतलब है जो दशकों तक ईमानदारी से काम किया है और एक से अधिक संकलक बच गए हैं? यह एक कठिन प्रश्न है। इस तथ्य के बावजूद कि कोड गलत है, कंपाइलर किसी तरह के अनस्पोक समझौते का पालन करते हैं और इसे एक समान तरीके से संसाधित करते हैं।

बहुत सोचने के बाद, मैंने अभी भी पीवीएस-स्टूडियो में इस नैदानिक ​​नियम को छोड़ने का फैसला किया, बिना किसी अपवाद के। यदि उपयोगकर्ताओं से बहुत अधिक शिकायतें हैं, तो शायद मैं अपना विचार बदल दूंगा। हालांकि, शायद उपयोगकर्ता इस डायग्नोस्टिक को बंद करने या अलर्ट को दबाने के लिए अन्य तरीकों का उपयोग करने की क्षमता से संतुष्ट हैं।

वैसे, यह इन मानसिक पीड़ाएं थीं जिन्होंने मुझे एक लेख लिखने के लिए प्रेरित किया। मुझे उम्मीद है कि मेरे द्वारा दिखाई गई जानकारी रोचक और उपयोगी होगी।

तो, आइए देखें कि शिफ्ट ऑपरेटरों के बारे में C ++ 11 मानक में क्या लिखा है:

पारी संचालक << और >> समूह बाएं से दाएं।

पारी-अभिव्यक्ति << योगात्मक-अभिव्यक्ति

पारी-अभिव्यक्ति >> योगात्मक-अभिव्यक्ति

ऑपरेंड अभिन्न या अनकैप्ड एन्यूमरेशन प्रकार के होंगे और इंटीग्रल प्रमोशन किए जाते हैं।

1. परिणाम का प्रकार प्रचारित बाएं ऑपरेंड है। यह व्यवहार अपरिभाषित है यदि सही ऑपरेंड नकारात्मक है, या पदोन्नत किए गए बाएं ऑपरेंड के बिट्स में लंबाई से अधिक या उसके बराबर है।

2. E1 का मान << E2 E1 बाएं-शिफ्ट किया गया E2 सा स्थान है; खाली बिट्स शून्य से भरे हुए हैं। यदि E1 का एक अहस्ताक्षरित प्रकार है, तो परिणाम का मान E1 * 2 ^ E2 है, परिणाम प्रकार में अधिकतम मूल्य प्रतिनिधित्व योग्य से एक से कम modulo। अन्यथा, यदि E1 में एक हस्ताक्षरित प्रकार और गैर-नकारात्मक मूल्य है, और E1 * 2 ^ E2 परिणाम प्रकार में प्रतिनिधित्व करने योग्य है, तो यह परिणामी मूल्य है; अन्यथा, व्यवहार अपरिभाषित है।

3. E1 >> E2 का मान E1 सही-स्थानांतरित E2 बिट स्थिति है। यदि E1 में एक अहस्ताक्षरित प्रकार है या यदि E1 में एक हस्ताक्षरित प्रकार और एक गैर-नकारात्मक मूल्य है, तो परिणाम का मान E1 / 2 ^ E2 के भागफल का अभिन्न अंग है। यदि ई 1 में एक हस्ताक्षरित प्रकार और एक नकारात्मक मूल्य है, तो परिणामस्वरूप मूल्य कार्यान्वयन-परिभाषित है।

ऐसे ग्रंथों को पढ़ना दुखद और दुखद है। लेकिन चिंता मत करो। अब हम उदाहरणों के साथ विभिन्न गलत स्थितियों पर विचार करेंगे।

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

  int ए = 10;
 int B = A << -5; 

तो भगवान का शुक्र है कि कोई नहीं करता है। कम से कम, 70 से अधिक ओपन-सोर्स प्रोजेक्ट का विश्लेषण करने के बाद, हमने ऐसी त्रुटियों का सामना नहीं किया।

निम्नलिखित मामला और अधिक दिलचस्प है। यह N बिट्स की एक शिफ्ट है, जहाँ N, बाएं ऑपरेंड में बिट्स की संख्या से अधिक है। सबसे सरल उदाहरण:

  int ए = 10;
 int बी = ए << 100; 

आइए देखें कि ऐसी गलती व्यवहार में कैसे दिख सकती है। निम्नलिखित कोड टुकड़ा Lib7z पुस्तकालय में हमारे द्वारा खोजा गया था:

  SZ_RESULT
 SafeReadDirectUInt64 (ISzInStream * इनस्ट्रीम, UInt64 * मान)
 {
   int i;
   * मूल्य = 0;
   के लिए (i = 0? मैं <8; मैं ++)
   {
     बाइट b;
     RINOK (SafeReadDirectByte (इनस्ट्रीम, और बी));
     * मूल्य | = ((UInt32) b << (8 * i));
   }
   वापसी SZ_OK;
 } 

पीवीएस-स्टूडियो डायग्नोस्टिक संदेश: V610 अपरिभाषित व्यवहार। शिफ्ट ऑपरेटर की जाँच करें <<। दाहिना ऑपरेंड ('(8 * i)' = [0..56]) प्रमोटेड लेफ्ट ऑपरेंड के बिट्स में लंबाई से अधिक या बराबर है। lib7z 7zin.c 233

फ़ंक्शन बाइट द्वारा 64-बिट मान बाइट को पढ़ने का प्रयास करता है। दुर्भाग्य से, वह सफल नहीं होगी यदि संख्या 0x00000000FFFFFFFFFFFF से अधिक थी। शिफ्ट पर ध्यान दें "(UInt32) b << (8 * i)"। बाएं ऑपरेंड का आकार 32 बिट्स है। इस स्थिति में, शिफ्ट 0 से 56 बिट्स तक होता है। व्यवहार में, यह इस तथ्य को जन्म देगा कि 64-बिट मूल्य का पुराना हिस्सा शून्य से भरा रहता है। सैद्धांतिक रूप से, आमतौर पर अपरिभाषित व्यवहार होता है और परिणाम अप्रत्याशित होता है।

सही कोड इस तरह दिखना चाहिए:

  * मूल्य | = ((UInt64) b << (8 * i)); 

पाठक पूछ सकता है, क्या कोड नीचे सही है?

  चार ए = 1;
 int B = A << 20; 

हाँ, सही है। ऑपरेटर के बाईं ओर << केवल एक चर A है, जिसमें केवल 8 बिट्स हैं। लेकिन शिफ्ट ऑपरेशन शुरू होने से पहले, बाईं ओर का विस्तार टाइप int तक किया जाएगा। तदनुसार, 'बिट' प्रकार का मान 20 बिट्स द्वारा स्थानांतरित किया जा सकता है।

और अब सबसे दिलचस्प पल। यह नकारात्मक मूल्यों में बदलाव है। सबसे सरल उदाहरण:

  int ए = -1 << 5;  // अपरिभाषित व्यवहार
 int बी = -1 >> 5;  // अनिर्दिष्ट व्यवहार 

इस कोड में अपरिभाषित और अनिर्दिष्ट व्यवहार होता है। व्यावहारिक दृष्टिकोण से इसमें कोई अंतर नहीं है। केवल एक निष्कर्ष है - आप ऐसा नहीं लिख सकते।

कोई भी इसका अंत कर सकता है और कुछ उदाहरण दे सकता है। दुर्भाग्य से, दो बारीकियां हैं जो दुनिया की सही तस्वीर को खराब करती हैं।

नूतन जो दुनिया की सही तस्वीर को खराब करते हैं

नुसान N १। 1998 के पुराने C ++ भाषा मानक में, अपरिभाषित व्यवहार वाली स्थितियों को दरकिनार किया जाता है। यह कहा जाता है कि अहस्ताक्षरित मूल्यों को स्थानांतरित करने पर ऑपरेटर << कैसे व्यवहार करता है। लेकिन प्रतीकात्मक अर्थों के बारे में कुछ नहीं कहा जाता है। सामान्य तौर पर, यह मामला है जब मानक पढ़ने से स्पष्टता नहीं जुड़ती है। इस तरह के मामले पर विचार नहीं किया गया है।

इसलिए, 1998 से C ++ के दृष्टिकोण से, निर्माण "-1 << 5" अपरिभाषित व्यवहार की ओर नहीं ले जाता है। हालांकि, यह कैसे काम करना चाहिए इसका भी वर्णन नहीं किया गया है।

नुन्स N2। प्रोग्रामर साहसपूर्वक कई कार्यक्रमों में नकारात्मक मूल्यों को स्थानांतरित करते हैं। और उनके साथ बहस करना मुश्किल होगा, क्योंकि कोड काम करता है।

आइए यह पता लगाने की कोशिश करें कि क्या इन बारीकियों के कारण, हमें एक नए निदान से इनकार करना चाहिए। हम सोचते हैं कि नहीं।

पुराना C ++ मानक अपरिभाषित व्यवहार के बारे में नहीं कहता है। नवीन कहता है। यह पता चला है कि पुराने मानक पर्याप्त रूप से सटीक नहीं थे। वैसे, नया सी भाषा मानक (मैंने 25 जून, 2010 के एक मसौदे को देखा) यह भी कहता है कि नकारात्मक मूल्यों के बदलाव से अपरिभाषित व्यवहार होता है। निष्कर्ष - आपको गलत कोड से छुटकारा चाहिए।

अब खतरनाक बदलावों के व्यापक उपयोग के बारे में। वास्तव में उनमें से बहुत सारे हैं। उदाहरण के लिए, JPEG लाइब्रेरी में, आपको निम्न मानों के साथ एक सरणी को पॉप्युलेट करने की आवश्यकता है:

  11111111111111111111111111111111b
 11111111111111111111111111111101b
 11111111111111111111111111111001b
 11111111111111111111111111110001b
 ... 

यह इस तरह लिखा है:

  / * प्रविष्टि n है (-1 << n) + 1 * /
 स्थिर कॉन्स्टेंस int Extended_offset [16] = {0,
   ((-1) << 1) + 1, (-1) << 2) + 1, (-1) << 3) + 1
   ((-1) << 4) + 1, (-1) << 5) + 1, (-1) << 6) + 1
   ((-1) << 7) + 1, (-1) << 8) + 1, (-1) << 9) + 1
   ((-1) << 10) + 1, (-1) << 11) + 1, (-1) << 12) + 1
   ((-1) << 13) + 1, (-1) << 14) + 1, (-1) << 15) + 1
 }; 

JPEG लाइब्रेरी को ख़राब कहना कठिन है। और यह कोड समय और विभिन्न संकलक द्वारा परीक्षण किया गया है।

मानक के दृष्टिकोण से, इसे अब इस प्रकार लिखा जाना चाहिए:

  स्थिर कॉन्स्टेंस int Extended_offset [16] =
 {0,
   ((~ 0u) << 1) |  1, ((~ 0u) << 2) |  1, ((~ 0u) << 3) |  1
   ((~ 0u) << 4) |  1, ((~ 0u) << 5) |  1, ((~ 0u) << 6) |  1
   ((~ 0u) << 7) |  1, ((~ 0u) << 8) |  1, ((~ 0u) << 9) |  1
   ((~ 0u) << 10) |  1, ((~ 0u) << 11) |  1, ((~ 0u) << 12) |  1
   ((~ 0u) << 13) |  1, ((~ 0u) << 14) |  1, ((~ 0u) << 15) |  1
 }; 

लेकिन क्या इस तरह के संपादन करना आपके लायक है? मैं केवल यह सब करने के लिए सलाह दे सकता हूं। यह पता नहीं है कि कब और कैसे, यह स्वयं प्रकट हो सकता है।

विभिन्न कार्यक्रमों में नकारात्मक मूल्य परिवर्तन के अन्य उदाहरण दिए जा सकते हैं। लेकिन वे सभी एक ही प्रकार के हैं, इसलिए उनके बारे में पढ़ना दिलचस्प नहीं होगा।

निष्कर्ष

1. पहले, बिट संचालन और पारियों का उपयोग प्रोग्रामर कौशल का संकेत था और आपको तेज कोड लिखने की अनुमति देता था। अब यह लगभग प्रासंगिक नहीं है। यह अधिक महत्वपूर्ण है कि कोड समझ में आता है। केवल आवश्यक होने पर ही बीट गेम्स का उपयोग करें।
2. "-1 << N" फ़ॉर्म की अभिव्यक्तियाँ अब अमान्य और अपरिभाषित व्यवहार के रूप में घोषित की गई हैं।
3. "-1 << N" फ़ॉर्म की अभिव्यक्तियाँ लंबे समय से अक्सर उपयोग की जाती रही हैं। इसलिए, ऐसे निर्माणों के उपयोग के खिलाफ वास्तविक तर्क देना मुश्किल है। तर्क केवल C और C ++ भाषाओं के नए मानक हैं।
4. अपने लिए तय करें कि नकारात्मक मूल्यों की पारी को सही करना है या नहीं। लेकिन मैं एक फिक्स की सलाह देता हूं। बस मामले में।
5. पीवीएस-स्टूडियो में खतरनाक बदलावों के बारे में डायग्नोस्टिक मैसेज 4.60 वर्जन से शुरू होंगे, जो जल्द ही जारी किए जाएंगे।

अतिरिक्त संसाधन

1. कांटा न जानने से, पानी में नहीं उतरता। भाग एक http://habrahabr.ru/post/137039/
2. कांटा न जानने से, पानी में नहीं उतरता। भाग दो http://habrahabr.ru/post/137411/
3. सीन एरॉन एंडरसन। बिट ट्विडलिंग हैक्स। http://www.viva64.com/go.php?url=837
4. विकिपीडिया। अपरिभाषित व्यवहार। http://www.viva64.com/go.php?url=663
5. विकिपीडिया। अनिर्दिष्ट व्यवहार। http://www.viva64.com/go.php?url=738
6. अलीना सी ++। अनिर्दिष्ट व्यवहार और अपरिभाषित व्यवहार के बीच का अंतर। http://www.viva64.com/go.php?url=739