आपके कॉन्स्टेक्स कॉर्टेक्सएम माइक्रोकंट्रोलर पर संग्रहीत हैं (उदाहरण के तौर पर C ++ IAR कंपाइलर का उपयोग करके)

मैं अपने छात्रों को STM32F411RE माइक्रोकंट्रोलर का उपयोग करना सिखाता हूं, जिसके बोर्ड पर ROM के 512 kB और RAM के 128 kB होते हैं
आमतौर पर इस माइक्रोकंट्रोलर पर, ROM मेमोरी को एक प्रोग्राम लिखा जाता है, और रैम में डेटा को बदल दिया जाता है जो रोम में स्थिरांक बनाने के लिए बहुत बार आवश्यक होता है।
STM32F411RE, ROM माइक्रोकंट्रोलर में, मेमोरी 0x08000000 ... 0x0807FFFF , और RAM के साथ 0x20000000 ... 0x2001FFFF के पते पर स्थित है ।

और यदि सभी लिंकर सेटिंग्स सही हैं, तो छात्र गणना करता है कि इस तरह के सीधे कोड में उसका निरंतर रॉम में निहित है:

class WantToBeInROM { private: int i; public: WantToBeInROM(int value): i(value) {} int Get() const { return i; } }; const WantToBeInROM myConstInROM(10); int main() { std::cout << &myConstInROM << std::endl ; } 

आप इस प्रश्न का उत्तर देने का भी प्रयास कर सकते हैं: ROM या RAM में निरंतर MyConstIn कहां है?

यदि आपने इस प्रश्न का उत्तर दिया है कि ROM में , मैं आपको बधाई देता हूं, तो वास्तव में सबसे अधिक संभावना है कि आप गलत हैं, निरंतर आम तौर पर RAM में झूठ होगा और यह पता लगाने के लिए कि ROM में आपके स्थिरांक को सही और सही तरीके से कैसे रखा जाए - बिल्ली का स्वागत है।

परिचय

सबसे पहले, एक छोटा विषयांतर, इस बारे में बिल्कुल परेशान क्यों।
IEC 61508-3: 2010 या GOST IEC 61508-3-2018 के घरेलू समकक्ष के मापन के लिए सुरक्षा महत्वपूर्ण सॉफ़्टवेयर विकसित करते समय , कई बिंदुओं को ध्यान में रखा जाना चाहिए, जो पारंपरिक सॉफ़्टवेयर के लिए महत्वपूर्ण नहीं हैं।

इस मानक का मुख्य संदेश यह है कि सॉफ़्टवेयर को किसी भी विफलता का पता लगाना चाहिए जो सिस्टम की विश्वसनीयता को प्रभावित करता है और सिस्टम को "क्रैश" मोड में डाल देता है।

स्पष्ट यांत्रिक विफलताओं के अलावा, उदाहरण के लिए, सेंसर विफलता या इलेक्ट्रॉनिक उपकरणों की विफलता और विफलता, सॉफ्टवेयर पर्यावरण की विफलता के कारण त्रुटियां, उदाहरण के लिए, रैम या रोम माइक्रोकंट्रोलर, का पता लगाया जाना चाहिए।

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

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

लेकिन डेटा भी हैं, जैसे कि पठनीयता के लिए एक निरंतर घोषित, एलसीडी ड्राइवर, एसपीआई या I2C की एक वस्तु, जिसे परिवर्तित नहीं किया जाना चाहिए, एक बार बनाया जाता है और जब तक कि बिजली बंद नहीं हो जाती तब तक हटा नहीं दिया जाता है।

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

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

इसलिए, सबसे आसान तरीका 100% सुनिश्चित करना है कि निरंतर डेटा रोम में है । यह कैसे करना है मैं समझाने की कोशिश करना चाहता हूं। लेकिन पहले आपको एआरएम में मेमोरी के संगठन के बारे में बात करने की आवश्यकता है।

मेमोरी संगठन

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

इस प्रकार, डेटा और कोड एक ही मेमोरी क्षेत्र में हो सकते हैं। इस एकल पते में जगह स्थित हो सकती है और रोम मेमोरी और रैम और बाह्य उपकरणों। और इसका मतलब है कि वास्तव में कोड और डेटा दोनों मिल सकते हैं, जहां यह संकलक और लिंकर पर निर्भर करता है।

इसलिए, ROM (फ्लैश) और RAM के लिए मेमोरी क्षेत्रों के बीच अंतर करने के लिए , उन्हें आमतौर पर लिंकर सेटिंग्स में इंगित किया जाता है, उदाहरण के लिए, IAR 8.40.1 में, यह इस तरह दिखता है:

 define symbol __ICFEDIT_region_ROM_start__ = 0x08000000; define symbol __ICFEDIT_region_ROM_end__ = 0x0807FFFF; define symbol __ICFEDIT_region_RAM_start__ = 0x20000000; define symbol __ICFEDIT_region_RAM_end__ = 0x2001FFFF; define region ROM_region = mem:[from __ICFEDIT_region_ROM_start__ to __ICFEDIT_region_ROM_end__]; define region RAM_region = mem:[from __ICFEDIT_region_RAM_start__ to __ICFEDIT_region_RAM_end__]; 

इस माइक्रोकंट्रोलर में RAM 0x20000000 ... 0x2001FFF, और ROM 0x008000000 ... 0x0807FFFF पर स्थित है ।
आप रैम एड्रेस को शुरुआती पता ROM_start को आसानी से बदल सकते हैं, RAM_start और अंतिम पते ROM_end__ को RAM_end__ में बदल सकते हैं और आपका प्रोग्राम पूरी तरह से RAM में स्थित होगा।
तुम भी विपरीत कर सकते हैं और ROM स्मृति क्षेत्र में रैम निर्दिष्ट करें, और आपका कार्यक्रम सफलतापूर्वक इकट्ठा और फ्लैश करेगा, हालांकि यह काम नहीं करेगा :)
कुछ माइक्रोकंट्रोलर्स, जैसे कि AVR, में शुरू में प्रोग्राम मेमोरी, डेटा मेमोरी और पेरिफेरल्स के लिए एक अलग एड्रेस स्पेस होता है, और इसलिए ऐसी ट्रिक वहां काम नहीं करेंगी, और प्रोग्राम को डिफ़ॉल्ट रूप से ROM पर लिखा जाता है।

CortexM में सभी पता स्थान एकल है, और कोड और डेटा कहीं भी स्थित हो सकते हैं। लिंकर सेटिंग्स का उपयोग करके, आप इस क्षेत्र को ROM और RAM पतों के लिए सेट कर सकते हैं। IAR रोम क्षेत्र में .text कोड सेगमेंट का पता लगाता है

ऑब्जेक्ट फ़ाइल और सेगमेंट

ऊपर, मैंने कोड सेगमेंट का उल्लेख किया है, आइए देखें कि यह क्या है।

प्रत्येक संकलित मॉड्यूल के लिए एक अलग ऑब्जेक्ट फ़ाइल बनाई जाती है, जिसमें निम्न जानकारी होती है:

• कोड और डेटा सेगमेंट
• DWARF डिबगिंग सूचना
• चरित्र तालिका

हम कोड और डेटा खंडों में रुचि रखते हैं । एक खंड एक ऐसा तत्व है जिसमें कोड या डेटा का एक टुकड़ा होता है जिसे स्मृति में भौतिक पते पर रखा जाना चाहिए। एक खंड में कई टुकड़े हो सकते हैं, आमतौर पर प्रत्येक चर या फ़ंक्शन के लिए एक टुकड़ा। एक सेगमेंट को ROM और RAM दोनों में रखा जा सकता है।
प्रत्येक खंड में एक नाम और एक विशेषता है जो इसकी सामग्री को परिभाषित करता है। लिंकर के लिए कॉन्फ़िगरेशन में एक खंड को परिभाषित करने के लिए विशेषता का उपयोग किया जाता है। उदाहरण के लिए, विशेषताएँ हो सकती हैं:

• कोड - निष्पादन योग्य कोड
• आसानी से - लगातार चर
• readwrite - आरंभिक चर
• शून्य-शून्य-प्रारंभिक चर

बेशक, अन्य प्रकार के सेगमेंट हैं, उदाहरण के लिए डिबगिंग जानकारी वाले सेगमेंट, लेकिन हम केवल उन लोगों में रुचि रखेंगे जिनमें हमारे एप्लिकेशन से कोड या डेटा शामिल हैं।

सामान्य तौर पर, एक खंड सबसे छोटा लिंक करने योग्य ब्लॉक होता है। हालांकि, यदि आवश्यक हो, तो लिंकर भी छोटे ब्लॉकों (टुकड़े) का संकेत दे सकता है। हम इस विकल्प पर विचार नहीं करेंगे, हम खंडों के साथ करेंगे।

संकलन के दौरान, डेटा और फ़ंक्शंस को अलग-अलग सेगमेंट में रखा गया है। और जोड़ने के दौरान, लिंकर विभिन्न खंडों को वास्तविक भौतिक पते प्रदान करता है। IAR संकलक के पूर्वनिर्धारित खंड नाम हैं, जिनमें से कुछ मैं नीचे प्रदान करूंगा:

• .bss - 0 के लिए स्थिर और वैश्विक चर शामिल हैं
• .CSTACK - प्रोग्राम द्वारा उपयोग किए गए स्टैक को शामिल करता है
• .data - इसमें स्थिर और वैश्विक आरंभिक चर शामिल हैं
• .data_init - डेटा के प्रारंभिक मान समाहित करता है। यदि लिंकर के लिए इनिशियलाइज़ेशन निर्देश का उपयोग किया जाता है
• HEAP - डायनेमिक डेटा होस्ट करने के लिए उपयोग किए गए हीप को समाहित करता है
• .intvec - एक रुकावट वेक्टर तालिका शामिल है
• .rodata - निरंतर डेटा समाहित करता है
• .text - इसमें प्रोग्राम कोड होता है

यह समझने के लिए कि स्थिरांक कहाँ स्थित हैं, हम केवल खंडों में रुचि रखेंगे
.rodata - एक खंड जिसमें स्थिरांक संग्रहीत हैं,
.data - एक खंड जिसमें सभी आरंभिक स्थिर और वैश्विक चर संग्रहीत हैं,
.bs - एक खंड जिसमें सभी स्थिर और वैश्विक .data चर शून्य (0) के साथ आरंभीकृत होते हैं:
.text - कोड संचय के लिए एक खंड।

व्यवहार में, इसका मतलब है कि यदि आप वैरिएबल int val = 3 को परिभाषित करते हैं, तो चर स्वयं कंपाइलर द्वारा .data सेगमेंट में स्थित होगा और रीडराइट विशेषता के साथ चिह्नित होगा, और नंबर 3 को या तो .text सेगमेंट में या .rodata सेगमेंट में रखा जा सकता है या यदि। .data_init में लिंकर के लिए एक विशेष निर्देश लागू किया जाता है और इसे इसके द्वारा आसानी से चिह्नित किया जाता है ।

.रोडाटा सेगमेंट में निरंतर डेटा होता है और इसमें निरंतर चर, स्ट्रिंग्स, कुल शाब्दिक और इसी तरह शामिल होते हैं। और इस सेगमेंट को मेमोरी में कहीं भी रखा जा सकता है।

अब यह स्पष्ट हो जाता है कि लिंकर सेटिंग्स में क्या निर्धारित है और क्यों:

 place in ROM_region { readonly }; //   .rodata  .data_init (  )  ROM: place in RAM_region { readwrite, //   .data, .bss,  .noinit block STACK }; //  STACK  HEAP  RAM 

यही है, रीडऑनली विशेषता के साथ चिह्नित सभी डेटा को ROM_region में रखा जाना चाहिए। इस प्रकार, विभिन्न क्षेत्रों के डेटा, लेकिन आसानी से विशेषता के साथ चिह्नित, ROM में प्राप्त कर सकते हैं।

लगातार डेटा

स्थिति को स्पष्ट करने से पहले, हमें पहले याद रखना चाहिए कि वैश्विक चर साझा स्मृति, स्थानीय चर, अर्थात् में बनाए जाते हैं। "सामान्य" फ़ंक्शन के अंदर घोषित चर स्टैक पर या रजिस्टरों में बनाए जाते हैं, और स्थिर स्थानीय चर भी साझा मेमोरी में बनाए जाते हैं।

C ++ में इसका क्या मतलब है। आइए एक उदाहरण देखें:

 void foo(const int& C1, const int& C2, const int& C3, const int& C4, const int& C5, const int& C6) { std::cout << C1 << C2 << C3 << C4 << C5 << C6 << std::endl; } //     constexpr int Case1 = 1 ; //  (      ) const int Case2 = 2; int main() { //  . const int Case3 = 3 ; // . static const int Case4 = 4 ; //      ,     . constexpr int Case5 = Case1 + 5 ; //     . static constexpr int Case6 = 6 ; foo(Case1,Case2,Case3,Case4,Case5,Case6); return 1; } 

यह सभी निरंतर डेटा है। लेकिन उनमें से किसी में ऊपर वर्णित निर्माण नियम लागू होता है, स्टैक पर स्थानीय चर बनाए जाते हैं। इसलिए, हमारी लिंकर सेटिंग्स के साथ, यह इस तरह होना चाहिए:

• Case1 वैश्विक स्थिरांक ROM में होना चाहिए। .Rodata खंड में
• Case2 वैश्विक स्थिरांक ROM में होना चाहिए। .Rodata खंड में
• Case3 स्थानीय स्थिरांक को RAM में झूठ होना चाहिए (स्थिर STACK सेगमेंट में स्टैक पर बनाया गया था)
• Case4 स्थिर स्थिरांक ROM में होना चाहिए। .Rodata खंड में
• Case5 स्थानीय स्थिरांक RAM में निहित होना चाहिए (एक दिलचस्प मामला है, लेकिन यह केस 3 के समान है)
• Case6 स्थिर स्थिरांक ROM में होना चाहिए। .Rodata खंड में

अब डिबगिंग जानकारी और जेनरेट मैप फाइल को देखें। डिबगर दिखाता है कि ये स्थिरांक कौन से पते पर हैं।



जैसा कि मैंने पहले कहा, पते 0x0800 ... ये ROM पते हैं, और 0x200 ... ये RAM हैं । आइए देखें कि संकलक ने इन स्थिरांक को किस खंड में बांटा है:

  .rodata const 0x800'4e2c 0x4 main.o //Case1 .rodata const 0x800'4e30 0x4 main.o //Case2 .rodata const 0x800'4e34 0x4 main.o //Case4 .rodata const 0x800'4e38 0x4 main.o //Case6 

चार वैश्विक और स्थैतिक स्थिरांक .रोडाटा सेगमेंट में गिर गए, और दो स्थानीय चर मैप फ़ाइल में नहीं आए क्योंकि वे स्टैक पर बनाए गए हैं और उनका पता स्टैक के पते से मेल खाता है। CSTACK खंड 0x2000'2488 से शुरू होता है और 0x2000'0488 पर समाप्त होता है। जैसा कि आप चित्र से देख सकते हैं, स्थिरांक केवल स्टैक की शुरुआत में बनाए गए हैं।

संकलक वैश्विक और स्थिर स्थिरांक को .rodata खंड में रखता है, जिसका स्थान लिंकर सेटिंग्स में निर्दिष्ट है।

यह एक और महत्वपूर्ण बिंदु ध्यान देने योग्य है, आरंभीकरण । स्थिरांक सहित वैश्विक और स्थिर वैरिएबल को आरंभीकृत किया जाना चाहिए। और यह कई तरीकों से किया जा सकता है। यदि यह .rodata सेगमेंट में एक स्थिर झूठ है, तो संकलन संकलन चरण पर होता है, अर्थात। मान उस पते पर तुरंत लिखा जाता है जहां स्थिर स्थित है। यदि यह एक नियमित चर है, तो आरओ मेमोरी से मूल्य को वैश्विक चर के पते पर कॉपी करके आरंभीकरण हो सकता है:

उदाहरण के लिए, यदि वैश्विक चर int i = 3 परिभाषित किया गया है, तो संकलक ने इसे डेटा डेटा खंड में परिभाषित किया है, लिंकर ने इसे 0x20000000 पर रखा है:
.data inited 0x2000'0000 ,
और इसका आरंभिक मूल्य (3) .xata खंड में 0x8000190 पते पर होगा:
Initializer bytes const 0x800'0190
यदि आप यह कोड लिखते हैं:

 int i = 3; const int c = i; 

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

अब अगर हम वापस अपने में जाते हैंऔर हम अपने आप से पूछते हैं: कंपाइलर ने किस वस्तु को निरंतर ऑब्जेक्ट myConstInROM को परिभाषित किया? और हमें उत्तर मिलता है: स्थिर .bs सेगमेंट में झूठ होगा , जिसमें स्थिर और वैश्विक चर होंगे जो शून्य (0) से आरंभिक होंगे।
.bss inited 0x2000'0004 0x4
myConstInROM 0x2000'0004 0x4

क्यों? क्योंकि C ++ में, एक डेटा ऑब्जेक्ट जिसे एक स्थिरांक के रूप में घोषित किया जाता है और जिसे डायनामिक इनिशियलाइज़ेशन की आवश्यकता होती है, रीड-राइट मेमोरी में स्थित होता है और इसे निर्माण के समय आरम्भ किया जाएगा।

इस स्थिति में, डायनेमिक इनिशियलाइज़ेशन होता है, const WantToBeInROM myConstInROM(10) , और कंपाइलर ने। ऑब्जेक्टिव सेगमेंट में सभी फ़ील्ड्स को इनिशियलाइज़ करते हुए .bs सेगमेंट में इस ऑब्जेक्ट को डाल दिया है, और फिर कंटेंट ऑब्जेक्ट बनाते समय, वैल्यू 10 के i फील्ड i को इनिशियलाइज़ करने के लिए कंस्ट्रक्टर कहा जाता है।

हम संकलक को अपनी वस्तु .rodata खंड में कैसे बना सकते हैं? इस प्रश्न का उत्तर सरल है, आपको हमेशा स्थैतिक आरंभ करना चाहिए। आप इसे इस तरह से कर सकते हैं:

1. हमारे उदाहरण में, यह देखा जा सकता है कि, सिद्धांत रूप में, कंपाइलर स्थिर करने के लिए गतिशील आरंभीकरण का अनुकूलन कर सकता है, क्योंकि कंस्ट्रक्टर काफी सरल है। संकलक के IAR के लिए, आप __ro_placement विशेषता के साथ स्थिरांक को चिह्नित कर सकते हैं
__ro_placement const WantToBeInROM myConstInROM
इस विकल्प के साथ, कंपाइलर चर को ROM में पते पर रखेगा:
myConstInROM 0x800'0144 0x4 Data
जाहिर है, यह दृष्टिकोण सार्वभौमिक नहीं है और आम तौर पर बहुत विशिष्ट है। इसलिए, हम सही तरीके से आगे बढ़ते हैं :)

2. यह एक constexpr बनाने के लिए है। हम तुरंत संकलक को स्थैतिक आरंभ का उपयोग करने के लिए कहते हैं, अर्थात्। संकलन चरण में, जब पूरे ऑब्जेक्ट को अग्रिम में पूरी तरह से "गणना" किया जाएगा और इसके सभी क्षेत्रों को जाना जाएगा। हमें बस इतना करना है कि कंस्ट्रक्टर में कंस्ट्रक्शन जोड़ें।


इसलिए, यह सुनिश्चित करने के लिए कि आपकी निरंतर वस्तु ROM में है, आपको सरल नियमों का पालन करने की आवश्यकता है:

1. .Text खंड जिसमें कोड रखा गया है वह ROM में होना चाहिए। इसे लिंकर सेटिंग्स में कॉन्फ़िगर किया गया है।
2. .Rodata सेगमेंट जिसमें वैश्विक और स्थिर स्थिरांक को ROM में रखा जाना चाहिए। इसे लिंकर सेटिंग्स में कॉन्फ़िगर किया गया है।
3. स्थिरांक वैश्विक या स्थिर होना चाहिए।
4. एक स्थिर चर वर्ग के गुण परिवर्तन योग्य नहीं होने चाहिए
5. वस्तु का आरंभीकरण स्थिर होना चाहिए, अर्थात उस वर्ग का निर्माता जिसका ऑब्जेक्ट स्थिर होगा उसे स्थैतिक होना चाहिए या उसे बिल्कुल भी परिभाषित नहीं किया जाना चाहिए (कोई गतिशील आरंभीकरण नहीं है)
6. यदि संभव हो तो, यदि आप सुनिश्चित हैं कि ऑब्जेक्ट को कास्ट उपयोग कॉन्स्टैक्स के बजाय ROM में संग्रहीत किया जाना चाहिए

कॉन्स्टैक्स और कॉन्स्ट्रेक्स कंस्ट्रक्टर के बारे में कुछ शब्द। Const और constexpr के बीच मुख्य अंतर यह है कि रनवे तक const वैरिएबल के आरंभीकरण में देरी हो सकती है। संकलित चर को संकलन समय पर आरंभ किया जाना चाहिए।
सभी constexpr चर प्रकार const के हैं।

कॉन्स्टैक्सप्र कन्स्ट्रक्टर की परिभाषा को निम्नलिखित आवश्यकताओं को पूरा करना चाहिए:

• एक क्लास में वर्चुअल बेस क्लास नहीं होना चाहिए।

   struct D2 : virtual BASE { //error, D2 must not have virtual base class. constexpr D2() : BASE(), mem(55) { } private: int mem; }; 

• कक्षा के प्रत्येक पैरामीटर प्रकार का शाब्दिक प्रकार होना चाहिए।
• कंस्ट्रक्टर बॉडी को = delete या = default होना चाहिए। या नीचे की आवश्यकताओं को पूरा करें:
• कंस्ट्रक्टर बॉडी में कोई भी try catch ब्लॉक नहीं हैं।
• कंस्ट्रक्टर बॉडी nullptr उपयोग कर सकता है
• कंस्ट्रक्टर बॉडी static_assert उपयोग कर सकता है
• कंस्ट्रक्टर के शरीर में, typedef का उपयोग किया जा सकता है जो कक्षाओं या गणनाओं को परिभाषित नहीं करता है
• निर्माणकर्ता निकाय निर्देशन और घोषणाओं using
• किसी वर्ग या आधार वर्ग के प्रत्येक गैर-स्थैतिक सदस्य को आरंभीकृत किया जाना चाहिए।
• एक वर्ग या बेस क्लास के कंस्ट्रक्टर, जिसका इस्तेमाल क्लास के सदस्यों के गैर-स्थैतिक तत्वों को शुरू करने के लिए किया जाता है और बेस क्लास के सब constexpr , को constexpr करना चाहिए।
• सभी गैर-स्थैतिक डेटा तत्वों के लिए constexpr होने चाहिए
• वर्ग के सदस्यों को आरंभ करते समय, सभी प्रकार के रूपांतरण स्थिर अभिव्यक्ति में मान्य होने चाहिए। उदाहरण के लिए, reinterpret_cast और void* से कास्टिंग void* किसी अन्य प्रकार के सूचक का उपयोग करने की अनुमति नहीं है

निहित डिफ़ॉल्ट कंस्ट्रक्टर कंस्ट्रक्टर कंस्ट्रक्टर है। अब कुछ उदाहरण देखते हैं:


इस तरह से लिखना बेहतर नहीं है, क्योंकि जैसे ही आप विशेषता i को शुरू करने का निर्णय लेते हैं, ऑब्जेक्ट RAM में उड़ जाएगा



























और अंत में, एक स्थिरांक फ़ंक्शन के माध्यम से सरणी आरंभीकरण के साथ एक सरणी युक्त एक स्थिर वस्तु।

 class Test { private: int k[100]; constexpr void InitArray() { int i = 0; for(auto& it: k) { it = i++ ; } } public: constexpr Test(): k() { InitArray(); // constexpr     } int Get(int index) const { return k[index]; } } ; int main() { static const Test test; //    ROM.     ,  constexpr . std::cout << test.Get(10) << std::endl ; return 0; } 

संदर्भ:
IAR C / C ++ डेवलपमेंट गाइड
कांस्टेक्स निर्माणकर्ता (C ++ 11)
कॉन्स्टैक्स (C ++)

पुनश्च।
Valdaros के साथ एक बहुत उपयोगी चर्चा के बाद, आपको निम्नलिखित बिंदु स्पर्शरेखा स्थिरांक जोड़ने की आवश्यकता है। C ++ मानक और इस दस्तावेज़ के अनुसार N1076.pdf

1. अपने जीवन के दौरान एक स्थिर वस्तु (किसी वर्ग के उत्परिवर्तित सदस्यों के अपवाद के साथ) में कोई भी परिवर्तन अपरिभाषित व्यवहार की ओर जाता है। यानी

  const int ci = 1 ; int* iptr = const_cast<int*>(&ci); //UB,       *iptr = 2 ; 

  int i = 1; const int* ci = &i ; int* iptr = const_cast<int *> (ci); //   *iptr = 2 ; // UB,   i 

2. समस्या यह है कि यह केवल एक स्थिर वस्तु के पूरे जीवन के दौरान काम करता है, लेकिन निर्माता और विध्वंसक में यह काम नहीं करता है। इसलिए, ऐसा करना काफी वैध है:

 class Test { public: int i; constexpr Test(): i(0) { foo(this) ; } } ; Test *test1; constexpr void foo(Test* value) { value->i = 1; //       0  1 test1 = value ; //           } const Test test; int main() { test1->i = 2; //          2. std::cout << &test << std::endl; } 

और इसे कानूनी माना जाता है। इस तथ्य के बावजूद कि हमने कॉन्स्ट्रेक्स कंस्ट्रक्टर का उपयोग किया, और इसमें कॉन्सटेक्प फ़ंक्शन। ऑब्जेक्ट सीधे रैम में जाता है।

इससे बचने के लिए, कॉन्स्ट के बजाय const - constexpr का उपयोग करें, फिर एक संकलन त्रुटि होगी जो आपको बताएगी कि कुछ गलत है और ऑब्जेक्ट स्थिर नहीं हो सकता है।

 class Test { public: int i; constexpr Test(): i(0) { foo(this) ; } } ; Test *test1; constexpr void foo(Test* value) { value->i = 1; //       0  1 test1 = value ; //           } constexpr Test test; // / Error[Pe2400]: calling the default constructor for "Test" does not produce a constant value main.cpp 151 int main() { test1->i = 2; //          2. std::cout << &test << std::endl; }