दिलचस्प पोस्ट
लूप के लिए स्विफ्ट: सूचक के लिए, तत्व में तत्व? WSDL सत्यापनकर्ता एंड्रॉइड पर हां / नहीं संवाद बॉक्स कैसे प्रदर्शित करें? गैर-पाया गया कुंजी के लिए डिफ़ॉल्ट मान वापस करने के लिए हैशमैप? Mongodb Query एक दिए गए कुंजी वाले अभिलेखों का चयन करने के लिए घटना धागा सुरक्षित रूप से उठाएं – सर्वोत्तम अभ्यास Firebase में चैट चैनल प्रबंधित करने का सर्वोत्तम तरीका दर्ज किए गए संपादन टेक्स्ट में पाठ साफ़ करें जावा-आधारित कॉन्फ़िगरेशन के साथ यह स्प्रिंग अनुप्रयोग ठीक से काम क्यों नहीं करता प्राथमिक कुंजी से धारावाहिक को प्राथमिक कुंजी कन्वर्ट करने के लिए कैसे? एक जार में पैकेजिंग फेसलेट फ़ाइलें (टेम्पलेट्स, शामिल हैं, कंपोजिट) एंड्रॉइड स्टूडियो लॉकैट शो में कुछ भी नहीं है $ ('<element>') बनाम $ ('<element />') jQuery में 24 घंटे के समय के साथ NSDateFormatter ASP.NET MVC के लिए प्लग-इन आर्किटेक्चर

Const और const अस्थिर के बीच का अंतर

यदि हम हर बार जब ताजा मूल्य नवीनीकृत किया जाता है तो एक परिवर्तनीय घोषित करते हैं
अगर हम const रूप में एक वैरिएबल घोषित करते हैं तो उस चर का मान बदला नहीं जाएगा

फिर const volatile int temp;
ऊपर के रूप में चर temp घोषित करने का क्या उपयोग है?
क्या होता है अगर हम const int temp रूप में घोषित करते हैं?

Solutions Collecting From Web of "Const और const अस्थिर के बीच का अंतर"

const volatile के रूप में चिह्नित एक ऑब्जेक्ट को कोड द्वारा परिवर्तित करने की अनुमति नहीं दी जाएगी ( const क्वॉलिफायर के कारण त्रुटि उत्पन्न होगी) – कम से कम उस विशेष नाम / पॉइंटर के माध्यम से।

क्वालीफ़ायर का volatile हिस्सा इसका मतलब है कि कंपाइलर ऑब्जेक्ट का एक्सेस या पुन: क्रमित नहीं कर सकता है।

एम्बेडेड सिस्टम में, यह आमतौर पर उन हार्डवेयर रजिस्टरों तक पहुंचने के लिए उपयोग किया जाता है जिन्हें पढ़ा जा सकता है और हार्डवेयर द्वारा अपडेट किया जाता है, लेकिन लिखने के लिए कोई अर्थ नहीं (या लिखने में त्रुटि हो सकती है)

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

यह स्थिति रजिस्टर (विशेष हार्डवेयर युक्ति के आधार पर) को लिखने के लिए कोई मतलब नहीं है, लेकिन आपको यह सुनिश्चित करने की आवश्यकता है कि प्रत्येक रीडर पढ़ने के लिए हार्डवेयर की वास्तविक रीडिंग में परिणाम – पिछली पठन से कैश्ड वैल्यू का उपयोग करके जीता गया ' आपको हार्डवेयर स्थिति में बदलाव के बारे में बताएंगे।

एक त्वरित उदाहरण:

 unsigned int const volatile *status_reg; // assume these are assigned to point to the unsigned char const volatile *recv_reg; // correct hardware addresses #define UART_CHAR_READY 0x00000001 int get_next_char() { while ((*status_reg & UART_CHAR_READY) == 0) { // do nothing but spin } return *recv_reg; } 

यदि इन संकेतों को volatile के रूप में चिह्नित नहीं किया गया था, तो कुछ समस्याएं हो सकती हैं:

  • जबकि लूप टेस्ट केवल एक बार स्टेटस रजिस्टर को पढ़ सकता है, क्योंकि संकलक यह मान सकता है कि जो कुछ भी यह इंगित करता है वह कभी भी बदले नहीं होगा (जबकि लूप टेस्ट में कुछ भी नहीं है या पाश जो इसे बदल सकता है)। यदि आप फ़ंक्शन में प्रवेश करते हैं, जब UART हार्डवेयर में कोई वर्ण प्रतीक्षा नहीं होती है, तो आप अनंत लूप में समाप्त हो सकते हैं, जब कोई वर्ण प्राप्त होने पर भी कभी भी रोका नहीं गया था।
  • रजिस्टर प्राप्त करने के बारे में पढ़ा जा सकता है कि संकलक से *recv_reg से पहले ले जाया जा सकता है – फिर भी क्योंकि फ़ंक्शन में कुछ भी नहीं है जो इंगित करता है कि *recv_reg को लूप के द्वारा बदल दिया गया है, कोई कारण नहीं है कि यह लूप दर्ज करने से पहले पढ़ा नहीं जा सकता है।

volatile क्वालिफायर यह सुनिश्चित करता है कि इन अनुकूलन को संकलक द्वारा नहीं किया जाता है।

  • volatile संकलक से संबंधित कोड को अनुकूलित करने के लिए नहीं बताएगा, आमतौर पर जब हम जानते हैं कि इसे "बाहर" से बदल दिया जा सकता है, जैसे कि किसी अन्य थ्रेड द्वारा।
  • const को कंपाइलर को बताएगा कि यह प्रोग्राम को वैरिएबल के मूल्य को संशोधित करने के लिए मना किया गया है।
  • const volatile एक बहुत ही खास बात है, आप शायद अपने जीवन (टीएम) में ठीक 0 बार इस्तेमाल करेंगे। उम्मीद की जानी चाहिए, इसका मतलब है कि कार्यक्रम चर का मूल्य संशोधित नहीं कर सकता है, लेकिन मान को बाहर से संशोधित किया जा सकता है, इस प्रकार वेरिएबल पर कोई भी अनुकूलन नहीं किया जाएगा।

ऐसा नहीं है क्योंकि वेरिएबल कॉन्स्ट है कि यह दो अनुक्रम बिंदुओं के बीच परिवर्तित नहीं हो सकता है

कॉन्सनेस एक वादा है जो आप मूल्य को बदलना नहीं चाहते हैं, न कि मूल्य को बदला नहीं जाएगा।

मुझे इसे एम्बेडेड अनुप्रयोग में उपयोग करने की ज़रूरत है जहां कुछ विन्यास चर फ्लैश मेमोरी के एक क्षेत्र में स्थित हैं जो बूटलोडर द्वारा अपडेट किए जा सकते हैं। इन कॉन्फ़िगरेशन चर रनटाइम के दौरान 'स्थिर' हैं, लेकिन बिना वाष्पशील क्वालीफायर के बिना कंपाइलर इस तरह कुछ अनुकूलित करेगा …

 cantx.id = 0x10<<24 | CANID<<12 | 0; 

… निरंतर मूल्य precomputing और एक तत्काल विधानसभा निर्देश का उपयोग करके, या पास के स्थान से लगातार लोडिंग, ताकि config फ़्लैश क्षेत्र में मूल CANID मान के लिए किसी भी अद्यतन को नजरअंदाज कर दिया जाएगा। CANID को अस्थिर होना चाहिए

const अर्थ है कि चर को सी कोड से संशोधित नहीं किया जा सकता है, यह नहीं बदल सकता है। इसका मतलब है कि कोई निर्देश चर को लिख सकता है, लेकिन इसकी कीमत अभी भी बदल सकती है।

volatile मतलब है कि चर किसी भी समय बदल सकता है और इस तरह कोई कैश्ड मूल्यों का उपयोग नहीं किया जा सकता है; वेरिएबल के प्रत्येक एक्सेस को इसकी मेमोरी एड्रेस पर कार्यान्वित किया जाना चाहिए।

चूंकि प्रश्न को "एम्बेडेड" कहा जाता है और अनुमानित temp उपयोगकर्ता एक घोषित वैरिएबल है, हार्डवेयर-संबंधित रजिस्टर नहीं है (चूंकि ये आमतौर पर एक अलग .h फाइल में संभाला जाता है), पर विचार करें:

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

यदि आप const temp को घोषित करने के लिए मान (कम से कम अगर 0 से अलग), तो कंपाइलर फ्लैस स्पेस में एक पते पर चर को असाइन करेगा, क्योंकि यहां तक ​​कि उसे एक रैम पता सौंपा गया है, फिर भी इसे स्टोर करने के लिए फ्लैश मेमोरी की आवश्यकता है वेरिएबल के प्रारंभिक मूल्य, जिससे रैम अंतरिक्ष की बर्बादी का पता लगाता है क्योंकि सभी ऑपरेशन केवल-पढ़ने योग्य हैं I

परिणामस्वरूप:

int temp; रैम में संग्रहीत एक चर है, स्टार्टअप (0) पर आरंभ करने के लिए, कैश किए गए मानों का उपयोग किया जा सकता है

const int temp; एक चर (पठन-ओनी) फ्लैश में संग्रहित है, जो कि संकलक समय में 0 से आरंभ किया जाता है, कैश किए गए मानों का उपयोग किया जा सकता है।

volatile int temp; एक आरएबल में संग्रहित एक चर है, जिसे स्टार्टअप पर 0 से प्रारंभ किया जाता है (सीआरटी), कैश किए गए मानों का उपयोग नहीं किया जाएगा।

const volatile int temp; एक चर (पठन-ओनी) फ्लैश में संग्रहित है, जिसे 0 से कंपाइलर समय पर आरंभ किया जाता है, कैश किए गए मानों का उपयोग नहीं किया जाएगा

यहाँ उपयोगी भाग आता है:

आजकल अधिकांश एंबेडेड प्रोसेसर में एक विशेष फ़ंक्शन मॉड्यूल के माध्यम से केवल पढ़ने के लिए नॉन-वाष्पशील मेमोरी में परिवर्तन करने की क्षमता होती है, जिसमें उस स्थिति में एंट const int temp को रनटाइम पर बदला जा सकता है, सीधे अलटेच नहीं। एक अन्य तरीके से कहा, एक समारोह उस पते पर मूल्य को संशोधित कर सकता है जहां temp जमा हो जाता है

एक व्यावहारिक उदाहरण डिवाइस सीरियल नंबर के लिए temp उपयोग करना होगा। पहली बार एम्बेडेड प्रोसेसर चलाता है, temp 0 (या घोषित मूल्य) के बराबर होगा और एक फ़ंक्शन उत्पादन के दौरान एक परीक्षण चलाने के लिए इस तथ्य का उपयोग कर सकता है और अगर sucessfull, एक सीरियल नंबर असाइन करने के लिए और temp मूल्य को संशोधित करने के लिए कहें एक विशेष समारोह के माध्यम से कुछ प्रोसेसर के लिए ओटीपी (एक बार प्रोग्रामयोग्य) मेमोरी के साथ एक विशेष पता श्रेणी है।

लेकिन यहां अंतर आता है:

यदि एक const int temp एक एक बार प्रोग्रामयोग्य सीरियल नंबर के बजाय एक परिवर्तनीय आईडी है, तो उसे अगले बूट तक उपयोग नहीं किया जा सकता, जिसका मतलब है कि नया आईडी अगली रिबूट, या यहां तक ​​कि तब तक मान्य नहीं हो सकता है इससे भी बदतर, कुछ फ़ंक्शंस नए मान का उपयोग कर सकते हैं, जबकि अन्य रीबूट के बिना पुराने कैश किए गए मान का उपयोग कर सकते हैं। यदि const int temp voltaile घोषित किया voltaile , तो आईडी परिवर्तन तुरंत प्रभावी होगा voltaile

यह आलेख उन परिदृश्यों की चर्चा करता है जहां आप कॉन्स्ट और वाष्पशील क्वालिफायर को जोड़ना चाहते हैं।

http://embeddedgurus.com/barr-code/2012/01/combining-cs-volatile-and-const-keywords/

सी में, const और अस्थिर प्रकार क्वालिफायर हैं और ये दो स्वतंत्र हैं

मूल रूप से, const का अर्थ है कि मूल्य कार्यक्रम के द्वारा संशोधित नहीं है।

और अस्थिर मतलब है कि मूल्य अचानक परिवर्तन (संभवतः कार्यक्रम के बाहर) के अधीन है।

वास्तव में, सी मानक में मान्य घोषणा का एक उदाहरण दिया गया है जो दोनों const और अस्थिर है। उदाहरण है

"एक्सटोर कॉन्स्ट वोल्टाइल इंट असली_टाइम घड़ी;"

जहां real_time_clock हार्डवेयर द्वारा संशोधित किया जा सकता है, लेकिन इसे आवंटित नहीं किया जा सकता, बढ़ता हुआ या घटाया हो सकता है।

तो हमें पहले से ही कॉन्स्ट और अस्थिर रूप से इलाज करना चाहिए। इसके अलावा, इन प्रकार के क्वालिफायर स्ट्रेट, यूनियन, एन्यूम और टाइपफीफे के लिए भी लागू होते हैं।

आप एक साथ const और अस्थिरता का उपयोग कर सकते हैं। उदाहरण के लिए, अगर 0x30 को एक बंदरगाह का मान मान लिया जाता है जो केवल बाहरी स्थितियों में बदल जाता है, तो निम्न घोषणा आकस्मिक दुष्प्रभावों की किसी भी संभावना को रोक देती है:

 const volatile char *port = (const volatile char *)0x30; 

हम एक परिवर्तनीय के लिए 'const' कीवर्ड का उपयोग करते हैं, जब हम प्रोग्राम को इसे बदलना नहीं चाहते हैं। जबकि जब हम एक चर 'कॉन्स्ट अस्थिरता' घोषित करते हैं तो हम प्रोग्राम को यह कह रहे हैं कि इसे और कंपाइलर नहीं बदलना चाहिए कि इस चर को अप्रत्याशित रूप से बाहरी दुनिया से आ रही इनपुट से बदला जा सकता है।