Constants and Inline Functions-accmUsQzNk0

C ++ में प्रोग्रामिंग के मॉड्यूल(module) 6 में आपका स्वागत है।
 पहले पांच मॉड्यूल(module) में, हमने सी प्रोग्रामिंग लैंग्वेज, सी स्टैंडर्ड लाइब्रेरी(library) और खुद सी लैंग्वेज के अलग-अलग कंस्ट्रक्शंस को रिकैपिटलाइज किया है।
 हमने प्राथमिक इनपुट(input) आउटपुट(output), अंकगणितीय संचालन, सरणियों, स्ट्रिंगस(strings) और विशेष रूप से डेटा(data) स्ट्रक्चर(structure) का उपयोग करने के लिए लूप प्रकार के उदाहरणों से शुरू होने वाले कई उदाहरणों को लिया है, हमने यह दिखाने के लिए चार का उदाहरण लिया कि C ++ में प्रोग्रामिंग और C ++ लाइब्रेरी(library) लाइब्रेरी(library) के विवेकपूर्ण उपयोग कैसे कर सकते हैं।
 C ++ में प्रोग्रामिंग करना वास्तव में अधिक कुशल और कम त्रुटि वाला आसान है।
 इस मॉड्यूल(module) से, अब हम C ++ प्रोग्रामिंग भाषा में विभिन्न विशेषताओं पर चर्चा करना शुरू करेंगे।
 अगले कुछ मॉड्यूल(module) में, हम विशेष रूप से सुविधाओं के एक सेट से निपटेंगे, जिन्हें आमतौर पर बेटर सी फीचर्स कहा जाता है, जो कि ये विशेषताएं हैं, जो C ++ में मौजूद ऑब्जेक्ट ओरिएंटेशन के मूल प्रतिमान का उपयोग नहीं करते हैं।
 लेकिन ये C भाषा के लिए प्रक्रियात्मक विस्तार हैं जो ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग को संभव बनाने के लिए आवश्यक हैं और ये इतनी अच्छी विशेषताएं हैं कि वे C में भी हो सकते हैं संयोग से वे भी नहीं सोचा गया था जब C को डिज़ाइन किया गया था।
 और दिलचस्प बात यह है कि C ++ में पेश किए जाने के बाद इनमें से कुछ विशेषताएं हैं, और हम इस मॉड्यूल(module) में उन विशेषताओं में से एक पर चर्चा करने जा रहे हैं।
 इनमें से कुछ विशेषताएं बाद में C प्रोग्रामिंग में ली गई हैं और अब C 99 मानक में उपलब्ध हैं।
 हम इस मॉड्यूल(module) 6 को शुरू करते हैं, जहां हम स्थिरांक और इनलाइन(Inline) कार्यों के बारे में चर्चा करेंगे।
 इसलिए, हम C ++ में const को समझने की कोशिश करेंगे और इसके विपरीत कि समान अवधारणा के साथ बिल्कुल समान अवधारणा नहीं है, लेकिन C में निरंतर प्रकट होने वाली समान अवधारणा और हम इनलाइन(Inline) कार्यों को समझाने की कोशिश करेंगे C ++ और उन्हें मैक्रोज़(macros) के साथ विपरीत।
 तो, ये ऐसे विषय हैं जिन पर हम चर्चा करेंगे, हम धीरे-धीरे प्रकट करेंगे कि आप इसे स्क्रीन के बाईं ओर देख सकते हैं।
 तो चलिए C में मैनिफेस्ट(manifest) कॉन्स्टेंट्स(constants) के साथ शुरू करते हैं।
 हम सभी जानते हैं कि हम किसी शाब्दिक या अभिव्यक्ति का उपयोग करते हुए एक स्थिर मान या निश्चित मान को परिभाषित कर सकते हैं, यदि हम #define लिखते हैं।
 एक नाम और फिर उस विशेष अभिव्यक्ति के बाद जिसे हम परिभाषित करना चाहते हैं।
 इसलिए, बाईं ओर हम इसके उदाहरण देख सकते हैं कि हमारे यहाँ क्या है; देखें TWO एक परिभाषित मूल्य है।
 2. इसी तरह, हमने दिखाया है कि pi को कैसे परिभाषित किया जाए जो एक अभिव्यक्ति के संदर्भ में परिभाषित हो।
 पीआई है; atan(1.0) जो कि PI से 4 है, इसलिए यदि आप इसे 4 से गुणा करते हैं तो आपको पाई का मान मिलता है।
 फिर हम उन्हें एक सर्कल की परिधि की गणना करने के लिए यहां अभिव्यक्ति में उपयोग करते हैं।
 यह एक प्रोग्राम है जो C में बहुत ही सामान्य रूप से उपयोग किया जाता है और आप में से कई ने पहले लिखा है।
 अब, हम इस प्रोग्राम(program) को थोड़ा अलग ढंग से देखते हैं, आइए हम दाहिने हाथ की ओर देखते हैं।
 #Define जो हमारे यहां TWO का था, वह अंत में C प्रीप्रोसेसर(preprocessor) द्वारा इस बिंदु पर प्रतिस्थापित हो जाता है।
 इसलिए, प्रोग्राम(program) के संकलन में जाने से पहले यह रेखा हटा दी जाती है और जहाँ भी TWO होता है, यह प्रतीक पहले हुआ था, यहाँ पहले की तरह जहाँ भी मुझे यह परिभाषित किया गया है कि प्रतीक होना चाहिए।
 तो, आप देख सकते हैं कि इस में pi को पूरी अभिव्यक्ति से बदल दिया गया है और यह वह कोड है जो वास्तव में C कंपाइलर(compiler) के संकलन के लिए जाता है।
 यह दृश्य परिदृश्य के पीछे है और हम आम तौर पर तब तक नहीं करते हैं जब तक कि आप अपने कोंपिलेर(compiler) में विशेष विकल्प नहीं डालते हैं आप प्रोग्राम(program) के इस संस्करण को नहीं देख पाएंगे, जहां बस इस #defines को बदल दिया गया है।
 #Define का उद्देश्य क्या है यह केवल प्रतीक और अभिव्यक्ति को समान नाम देना है और सी प्रीप्रोसेसर(preprocessor) प्रतिस्थापन कर सकता है।
 यह आपको केवल यह समझने के लिए है कि एक प्रकट स्थिरांक का परिदृश्य क्या है? तो, इसका परिणाम क्या होगा? परिणाम यह है कि मैं वास्तव में एक मूल्य का उपयोग करना चाहता था जिसे मैं निरंतर रूप से व्यवहार करना चाहता था, लेकिन जब से मुझे यह मिल गया है अगर मैं इसे फिर से देखता हूं और टिप्पणी में अंतिम पंक्ति पर ध्यान केंद्रित करता हूं, तो मैं इसे एक मुक्त रूप में उपयोग करना चाहता था स्थिरांक और इस प्रक्रिया में कोंपिलेर(compiler) को वास्तव में कभी पता नहीं चलता है कि वे TWO नामक एक चर(variable) के रूप में थे या वे TWO नामक एक प्रतीक थे, कोंपिलेर(compiler) उस संख्यात्मक 3 को देखता है क्योंकि इसे प्रतिस्थापित किया गया है।
 तो इस बात का ख्याल रखने के लिए एक notion ऑफ const-ness की शुरुआत की गई है।
 इसलिए, यदि हम देखते हैं कि कॉन्स्ट(const)-नेस(ness) कैसे किया जाता है, तो आप देखते हैं कि हम एक घोषणा कर रहे हैं जहां हम नए कीवर्ड कॉन्स्ट(const) द्वारा n की घोषणा को उपसर्ग करते हैं।
 अगर मैं अभी int n initialize 10 लिखता हूँ तो हम जानते हैं n एक पूर्णांक प्रकार का वैरिएबल(variable) है जिसका प्रारंभिक मान 10 है।
 हम इसे इस कॉन्स्ट(const) कीवर्ड के साथ प्रीफ़िक्स कर रहे हैं, अगर हम ऐसा करते हैं कि इसका क्या अर्थ है n का प्रारंभिक मूल्य 10 है और यह भी कहता है इसे भविष्य में नहीं बदला जा सकता है, जो कि किसी भी असाइनमेंट(assignment) या किसी अन्य माध्यम से मैं n बदल सकता हूं, n प्रोग्राम(program) के माध्यम से 10 तक रहेगा।
 इसलिए, अगर मैं यहां ऐसा कुछ करने की कोशिश करता हूं, जो 5 को सौंपा गया है और उस कोड को संकलित करने की कोशिश करता है, तो कोंपिलेर(compiler) एक त्रुटि देगा कि एन निरंतर है इसे बदला नहीं जा सकता है।
 मैं इसे बायपास करने की कोशिश कर सकता हूं और कुछ इस तरह से कर सकता हूं जैसे कि आम तौर पर अगर मेरे पास एक और वेरिएबल m और एक पॉइंटर(pointer) p होता है जो एक पूर्णांक प्रकार का पॉइंटर(pointer) होता है तो मैं m और p का पता लेता हूं और निश्चित रूप से मैं पॉइंटर(pointer) का उपयोग कर सकता हूं m का मान, अगर मैं सात से *p असाइन करता हूं तो इसका मतलब है कि यह वास्तव में मीटर बदलता है।
 लेकिन, अगर मैं यहाँ भी ऐसा ही करने की कोशिश करता हूँ, अगर मैं n के इस मान को संकेतित चर(variable) p में और बाद में n के मान को बदलने की कोशिश करता हूँ, तो संभवतः मैं *p को 5 असाइन कर सकता हूँ, मुझे इसकी अनुमति नहीं दी जाएगी।
 वो करें।
 तो, आप थोड़ा आश्चर्यचकित हो सकते हैं कि यदि हम एक चर(variable) को कॉन्स्ट(const) के रूप में परिभाषित करते हैं और फिर एक पॉइंटर(pointer) का उपयोग करने का प्रयास करते हैं और उसका पता भी लेते हैं, जो कि संकलन त्रुटि के रूप में दिया गया है।
 और कारण यह एक संकलन त्रुटि है यदि यह कोई त्रुटि नहीं है, तो आप ऐसा करने में सक्षम होंगे, जो कि कॉन्स्ट(const)-नेस(ness) के सिद्धांत के उल्लंघन में है जिसे हम परिभाषित करने की कोशिश कर रहे हैं, कि हम यह कहना चाह रहे हैं कि n बदला नहीं जा सकता।
 इसका क्या परिणाम होता है? इसका अगला प्राकृतिक परिणाम है एक कॉन्स्ट(const) वैरिएबल(variable) को इनिशियलाइज़ किया जाना चाहिए।
 जैसे ही यह परिभाषित हो रहा है, इसे प्रारंभ किया जाना चाहिए, क्योंकि यदि आप इसे प्रारंभ नहीं करते हैं, तो इसके मूल्य को बदलने का कोई तरीका नहीं है, इसलिए जो भी कचरा मूल्य है, वह केवल कचरा होगा।
 इसलिए, यदि आप बिना आरंभीकरण के एक कॉन्स्ट(const) चर(variable) घोषित करते हैं जो एक संकलन त्रुटि बन जाएगा।
 तो हम विभिन्न प्रकारों के वैरिएबल(variable) भी घोषित कर सकते हैं क्योंकि कॉन्स्ट(const) प्रकार का उपयोग चर(variable) का एक उदाहरण है जो एक जटिल संख्या कहती है और हम इसे परिभाषित कर सकते हैं निरंतर जिसका अर्थ यह होगा कि इस नक्षत्र के साथ आप किसी घटक के चर(variable) के मान को बदलने में सक्षम नहीं होंगे c.c. सी।
 परिभाषा के अनुसार re 2.3 हो गया है क्योंकि हमने इनिशियलाइज़ किया है और क्योंकि हमने कहा है कि c const है, अगर c const है तो यह पूरा है, क्योंकि मैं किसी भी कंपोनेंट को नहीं बदल सकता।
 इसलिए, अगर मैं 3.5 से c.re असाइन करने का प्रयास करता हूं तो यह एक संकलन त्रुटि होगी।
 यह कॉन्स्ट(const)-नेस(ness) की धारणा है।
 तो आइए देखें कि हम इसका इस्तेमाल कैसे करते हैं।
 तो, अब हम दो प्रोग्राम्स को बाईं ओर रखते हैं, विशिष्ट C प्रोग्राम जो #define का उपयोग करता है और दाईं ओर हम C ++ में एक समान प्रोग्राम लिखते हैं जो समान उद्देश्य को प्राप्त करने के लिए const-ness का उपयोग करता है।
 पहले हम वैल्यू 2 में #define TWO लिख रहे थे, अब हम कह रहे हैं कि TWO एक प्रकार का पूर्णांक है, जिसे 2 के साथ आरंभीकृत किया जाता है, लेकिन यह एक कास्ट वैरिएबल(variable) है, इसलिए आप इसे बदल नहीं सकते।
 इसका प्रमुख परिणाम यह है कि दाहिने हाथ की ओर यह प्रोग्राम(program), जब यह प्रोग्राम(program) सही हो जाता है, तो सी प्रीप्रोसेसर(preprocessor) ने निश्चित रूप से कहा कि यह कोई #define नहीं है, इसलिए इस बिंदु पर प्रतीक TWO को प्रतिस्थापित नहीं किया जाएगा।
 इसी तरह, प्रतीक PI रहेगा और कंपाइलर(compiler) को यह देखने को मिलेगा कि ये अलग-अलग वैरिएबल(variable) हैं जो प्रोग्राम में मौजूद हैं और कंपाइलर(compiler) जानता है कि ये स्थिर हैं जिन्हें बदला नहीं जा सकता है।
 तो आप उसी उद्देश्य को प्राप्त कर सकते हैं जो आपके पास C में था और आपको अतिरिक्त लाभ मिलता है कि अब कंपाइलर(compiler) इन सभी को देख सकता है और कंपाइलर(compiler) को पता चल जाएगा कि TWO का प्रकार क्या है, कंपाइलर(compiler) को पता होगा कि PI का प्रकार क्या है या उसके लिए क्या है किसी भी चर(variable), किसी भी मूल्य को परिभाषित करें जो आप कॉन्स्ट(const) कीवर्ड का उपयोग करके निरंतर होने के लिए परिभाषित करते हैं।
 तो इसका उपयोग करने के मामले में आपको बहुत सारे लाभ मिलते हैं।
 दो प्रमुख संदर्भ हैं जिनमें आप निरंतर मूल्यों का उपयोग करना चाहते हैं; एक संदर्भ यह है कि जब आप पीआई जैसे विभिन्न प्राकृतिक स्थिरांक से निपटते हैं तो ई की तरह स्वर्ण अनुपात phi जैसे बूलियन सत्य मान गलत मान शून्य मान और इसी तरह।
 प्रोग्राम(program) में कई प्राकृतिक स्थिरांक होते हैं जो निश्चित रूप से आप हमेशा उन्हें इस आधार के साथ परिभाषित कर सकते हैं कि उनके पास उनका मूल्य होगा, उनके पास उनका प्रकार होगा, और उनकी मूल property होगी कि प्राकृतिक स्थिरांक स्वाभाविक रूप से, आप मूल्य को बदल नहीं सकते हैं PI या आप E का मान नहीं बदल सकते हैं, इसलिए property को भी बनाए रखा जाएगा।
 इसके अलावा, एक अन्य जगह जहां हम अक्सर निरंतर का उपयोग करते हैं, वह है जहां कुछ मेरे प्रोग्राम(program) के लिए स्थिर है या कुछ एक विशेष फ़ंक्शन के लिए स्थिर है।
 तो, इसके लिए हम परिभाषाओं के दूसरे सेट का उपयोग करेंगे जैसे कि हम एक सरणी आकार हो सकते हैं जो एक स्थिरांक के रूप में परिभाषित हो सकता है।
 ये सार्वभौमिक प्राकृतिक स्थिरांक नहीं हैं, लेकिन ये मेरे कार्य के लिए स्थिरांक हैं।
 अगर मैंने ऐसा किया है, तो हमें जो लाभ मिलता है, जब हम प्रोग्राम लिखते हैं, तो हम उन्हें इन चरों के संदर्भ में लिख सकते हैं ताकि बाद में अगर हमें उन्हें बदलना पड़े तो हम सिर्फ इनीतियालीजटिओन बदल सकते हैंनिरंतर के जो प्रोग्राम(program) के शीर्ष पर या कुछ शीर्ष लेख फ़ाइल में संभवतः है।
 ऐसा करने का एक और फायदा है, अगर आप #define करते हैं, तो #define का पूरे फाइल पर स्कोप है।
 अगर मैं कुछ मान n को एक निश्चित विशिष्ट स्थिर मान के लिए बताता हूं, तो जहाँ भी मेरे प्रोग्राम(program) में n है, इस #define मान से प्रतिस्थापित हो जाता है।
 लेकिन const एक वैरिएबल(variable) डिक्लेरेशन है, इसलिए इसे किसी भी स्कोप में किया जा सकता है, मैं इसे फंक्शन के भीतर कर सकता हूं, मैं इसे एक फंक्शन के भीतर एक ब्लॉक में कर सकता हूं और किसी भी वैरिएबल(variable) डिक्लेरेशन की तरह कॉन्स्ट(const) का वेरिएबल डिक्लेरेशन भी उस स्कोप के भीतर सीमित रहेगा।
 इसलिए यह संभव है कि मेरे पास एक ही चर(variable) n एक ही फाइल में दो अलग-अलग फ़ंक्शन में हो रही है, दोनों जगह यह स्थिर है, लेकिन इसके अलग-अलग मूल्य हैं, आप #define के साथ इस तरह के प्रभाव को प्राप्त नहीं कर सकते।
 हम संक्षेप में कहते हैं कि हम #define से अधिक कॉन्स्ट(const) को पसंद करते हैं क्योंकि यह प्रकार के संदर्भ में सुरक्षित नहीं है, इसे CPP द्वारा प्रतिस्थापित किया जाता है जहां कॉन्स्ट(const) नहीं है।
 इसलिए, यदि आप डिबगर का उपयोग कर रहे हैं, तो आप डिबगर में #define प्रतीकों को नहीं देख पाएंगे, क्योंकि आप इसे देख पाएंगे।
 दूसरा साइड इफेक्ट तब से है, जब #define ने हर बिंदु पर अभिव्यक्ति को बदल दिया है, जिसका मूल्यांकन करने की आवश्यकता है क्योंकि इसे कई बार प्रतिस्थापित किया जाता है, जहां कॉन्स्ट(const) के मामले में इसे केवल आरंभीकरण बिंदु पर मूल्यांकन किया जाता है।
 तो, कास्ट निश्चित रूप से #define पर एक पूर्ण लाभ है।
 अब, हम विशेष रूप से कॉन्स्ट(const) को परिभाषित करने के कुछ परिणामों को देखते हैं, हम पॉइंटर(pointer) टाइप डेटा(data) के कॉन्स्टेंस(const)-नेस(ness) को देखेंगे।
 एक पॉइंटर(pointer) प्रकार के डेटा(data) में हम जानते हैं कि हमारे पास एक पॉइंटर(pointer) है और यह एक चर(variable) की ओर इशारा करता है।
 तो सवाल यह है कि अगर हम const-ness की बात करते हैं तो हम किस const-ness की बात कर रहे हैं, क्या आप पॉइंटर(pointer) के const-ness या पॉइंटेड डेटा(data) के const-ness के बारे में बात कर रहे हैं।
 यहां, हम दो चीजों के बारे में बात करते हैं जो निरंतर डेटा(data) की ओर इशारा करते हैं कि क्या डेटा(data) स्थिर है, लेकिन पॉइंटर(pointer) नहीं है या पॉइंटर(pointer) स्वयं स्थिर है, लेकिन डेटा(data) स्थिर हो सकता है या नहीं हो सकता है।
 यहाँ नीचे मैं केवल एक विशिष्ट उदाहरण दिखाता हूं कि हम पॉइंटर(pointer) और पॉइंटी के साथ कैसे गणना करते हैं हमने दो चर(variable) को परिभाषित किया है, इसलिए हमारे पास एक पॉइंटर(pointer) है जो एक चर(variable) का पता लेता है और फिर इसका उपयोग करके मैं सीधे चर(variable) को बदल सकता हूं या मैं बदल सकता हूं पॉइंटर(pointer) के माध्यम से।
 इसी तरह, इस रेखा पर, पहले पॉइंटर(pointer) n की ओर इशारा कर रहा था, अब इसे m को इंगित करने के लिए बदल दिया गया है और वे फिर से m का मान बदलने के लिए इसका उपयोग कर सकते हैं।
 यह एक पॉइंटर(pointer)-पॉइंट्टी परिदृश्य का विशिष्ट उपयोग है।
 इसलिए, इसके साथ हम चर्चा करेंगे कि हम इस बदलाव को कैसे नियंत्रित कर सकते हैं कॉन्स्ट(const) का इस्तेमाल करके।
 (स्लाइडसमय का संदर्भ लें: 17:34) तो पहला है, अगर मेरे पास एक निरंतर डेटा(data) के लिए एक संकेतक है।
 तो, हम यहां क्या कर रहे हैं, क्या हमने डेटा(data) के पहले कॉन्स्टेंट(constant) लिखा है, इससे पहले कि पॉइंटर(pointer) किस प्रकार के मान को इंगित करता है।
 यदि मैं इस बिंदु पर कॉन्स्ट(const) लिखता हूं तो इसका मतलब है कि इंगित डेटा(data) स्थिर है, इसे बदला नहीं जा सकता है।
 तो, n को एक स्थिर मूल्य के रूप में परिभाषित किया गया है।
 हम पहले से ही जानते हैं कि n का मान बदलने का प्रयास एक त्रुटि है क्योंकि यदि n स्थिर है, और हमने p को n के लिए एक पॉइंटर(pointer) माना है।
 तो, n का उपयोग करते हुए n के मान को बदलने की कोशिश कर रहा है जो * p असाइन किया गया 7 भी एक त्रुटि है।
 लेकिन, p अपने आप में एक स्थिरांक नहीं है, यही कारण है कि अगर मैं चाहता हूं कि मैं कुछ अन्य चर(variable) के लिए p बिंदु बना सकता हूं, तो m यहां एक चर(variable) है जो एक स्थिर चर(variable) नहीं है।
 मैं m को p पॉइंट बना सकता हूं और फिर मैं m का मान बदलने के लिए इस * p असाइन किए गए 8 का उपयोग कर सकता हूं, m अब 8 हो जाएगा, यह 4 हो गया, यह अब 8 हो जाएगा।
 अब अगर आप देखेंगे, अगर मेरे पास एक वैरिएबल(variable) है जो निरंतर नहीं है int को एक पूर्णांक प्रकार के रूप में परिभाषित किया गया है जिसे 5 के साथ आरंभीकृत किया गया है और मेरे पास एक पॉइंटर(pointer) पी है जो एक निरंतर प्रकार के पूर्णांक मान को इंगित करता है और मैंने डाला।
 p में n का पता।
 अब, स्वाभाविक रूप से 6 से n का m असाइनमेंट(assignment) मान्य है क्योंकि n स्वयं एक स्थिरांक नहीं है।
 यह भी है कि * p असाइन किया गया 6 मान्य है, लेकिन अगर मैं ऐसा करने का प्रयास * p असाइन किया गया 6 जो मान्य नहीं है, क्योंकि p कहता है कि m निरंतर पूर्णांक की ओर इशारा करता है।
 तो बहुत दिलचस्प परिदृश्य; मैं यहाँ एपी है जो n की ओर इशारा कर रहा है।
 पी जानता है, यह जानता है कि अगर मैं * पी लिखता हूं, तो स्थिर है।
 इस मान को बदलने के लिए p का उपयोग नहीं किया जा सकता है, लेकिन n स्वयं स्थिर नहीं है।
 तो, n बदला जा सकता है।
 अब, यह मान्य है क्योंकि आप जो कह रहे हैं, आप जो आवश्यकता है, उससे अधिक कह रहे हैं, आप कह रहे हैं कि n अपने आप बदल सकता है।
 इसलिए, चाहे मैं इसे सीधे n के रूप में बदलूं या मैं इसे पॉइंटर(pointer) के माध्यम से बदलूं, इससे कोई फर्क नहीं पड़ता क्योंकि n बदल सकता है, लेकिन पॉइंटर(pointer) ने कहा कि मैं बदलने के लिए प्रतिबंधित हूं।
 पॉइंटर(pointer) ने कहा है कि यदि आप मेरे माध्यम से जाते हैं तो मैं आपको मूल्य बदलने की अनुमति नहीं दूंगा।
 तो, यहाँ यह एक ऐसा परिदृश्य है जहाँ चर(variable) वास्तव में बदल सकता है, लेकिन पॉइंटर(pointer) एक दृश्य देता है जो आपको इसे बदलने की अनुमति नहीं देता है, लेकिन अगर मैं सीधे जाता हूं या यदि मैं कुछ अन्य पॉइंटर(pointer) का उपयोग करता हूं जो एक निरंतर मान को इंगित नहीं करता है तो हम को बदलने में सक्षम हो जाएगा।
 अंत में, यदि हम रिवर्स करने की कोशिश करते हैं, अगर मेरे पास एक निरंतर चर(variable) n है और अगर मैं एक गैर स्थिर मान p के लिए एक पॉइंटर(pointer) का उपयोग करने की कोशिश करता हूं, तो फिर भी मैं ऐसा करने में सक्षम नहीं होगा।
 इसलिए, यदि हम अभी वर्णन करने की कोशिश करते हैं, तो यहाँ अंतिम अन्तिम मामला है, इसलिए हम इस मामले के बारे में बात कर रहे हैं, यदि मेरे पास एप है जो n को इंगित करता है, जहां यह निरंतर है और * p स्थिर नहीं है तब हमारे पास एक त्रुटि काफी वैध है, क्योंकि n एक स्थिर है।
 यदि * p स्थिर नहीं है, * p n को इंगित करने का प्रयास कर रहा है, तो मैं हमेशा n का मान बदलने के लिए यहां * p का उपयोग कर सकता हूं जो कि करने वाला नहीं है।
 इसलिए हमने यहां जो सीखा वह एक बुनियादी धारणा है कि अगर कोई मूल्य स्थिर नहीं है, तो मैं अभी भी इसका उपयोग कर सकता हूं कि यह देखने के लिए एक निरंतरता को इंगित करता है कि, इसे प्राप्त करें, लेकिन मैं इसे उस पॉइंटर(pointer) में नहीं बदल पाऊंगा।
 लेकिन यदि कोई मान स्थिर है, तो मैं एक पॉइंटर(pointer) का उपयोग नहीं कर सकता हूं जो एक गैर स्थिर मान को इंगित करता है मुझे इस निरंतर चर(variable) के पते के साथ उस कॉन्स्ट(const) पॉइंटर(pointer) को शुरू करने की अनुमति नहीं दी जाएगी क्योंकि यह कॉन्स्टेंट(constant)-नेस(ness) के मूल सिद्धांत का उल्लंघन करेगा ।
 इसके बाद, हम दूसरी तरफ के कॉन्स्टेंट(constant)-नेस(ness) को देखें, अगर पॉइंटर(pointer) स्थिर है, तो क्या होगा? इसलिए, यदि आप यहां देखें कि यह वह जगह है जहां हम हैं, तो हमने उस स्थिति को थोड़ा स्थानांतरित कर दिया है जहां हमने कास्ट लिखा था।
 पहले इस बिंदु पर यहाँ कॉन्स्टेंट(constant) लिखा गया था, अब स्टार चिन्ह के बाद कॉस्ट लिखा जाता है, यह कहता है कि पॉइंटर(pointer) स्थिर है, लेकिन यह जिस मान की ओर इशारा कर रहा है वह स्थिर नहीं है।
 अगर मैं इसे खींचता हूं तो पी कॉन्स्ट(const) है और n कॉन्स्ट(const) नहीं है।
 तो, इसका क्या मतलब है कि अगर मैं आसानी से लिख सकता हूं कि यह n कॉन्स्ट(const) नहीं है, तो मैं इसकी वैल्यू बदल सकता हूं, क्योंकि n कॉन्स्ट(const) नहीं है, मैं p deference का उपयोग कर सकता हूं यह सात से * p असाइन करता है जो n का वैल्यू बदल देगा।
 क्योंकि मैं किसी भी चीज का उल्लंघन नहीं कर रहा हूं, लेकिन मैं ऐसा नहीं कर पाऊंगा, वह आखिरी है जो मैं पी में संग्रहीत पते को नहीं बदल सकता।
 मैं अब p को एक नए चर(variable) m की ओर इंगित नहीं कर सकता, क्योंकि मैंने कहा है कि पॉइंटर(pointer) स्वयं स्थिर है यह पक्ष निरंतर है अब पहले वाला दूसरा पक्ष स्थिर था।
 स्वाभाविक रूप से, अगर हमारे पास यह है तो विस्तार से हम इस दोनों को भी जोड़ सकते हैं कि पॉइंटर(pointer) और डेटा(data) जो इसे इंगित कर रहा है वह निरंतर हो सकता है।
 इसलिए, हम यहां एक उदाहरण दिखा रहे हैं, जहां मैं दोनों तरफ कास्ट लिखता हूं, जिसका अर्थ है कि p एक निरंतर डेटा(data) के लिए एक पॉइंटर(pointer) है, जिसका अर्थ है कि न तो p किसी अन्य को इंगित करने के लिए बनाया जा सकता है n के अलावा अन्य चर(variable) और न ही n का मान बदलने के लिए p का उपयोग कर सकते हैं।
 तो, यह सब अब त्रुटि हो जाएगी।
 अब, निश्चित रूप से, चूंकि हम इंगित किए गए डेटा(data) या पॉइंटर(pointer) पर कॉन्स्ट(const)-नेस(ness) लिख रहे हैं, इसलिए यह कई बार भ्रमित होता है कि मुझे कॉन्स्ट(const) कहां लिखना चाहिए और कॉन्स्ट(const) कीवर्ड डालकर क्या हो जाएगा।
 अंगूठे का नियम बहुत सरल है, कि जब आपके पास यह घोषणा पूरी घोषणा में स्टार प्रतीक पर दिखती है।
 मानसिक रूप से एक ऊर्ध्वाधर रेखा खींचें ताकि यदि आप ऐसा करने की कोशिश कर रहे हैं तो आप const int * p वगैरह कह रहे हैं, इस स्टार प्रतीक के माध्यम से एक ऊर्ध्वाधर रेखा खींचें और देखें कि const कीवर्ड किस तरफ दिखाई देता है, यह है आपका डेटा(data) पक्ष और यह आपका इंगित पक्ष है।
 इसलिए यदि कास्ट-नेस(ness) डेटा(data) की तरफ है तो आप जो भी इशारा कर रहे हैं वह स्थिर है।
 इसके विपरीत यदि आपके पास int * const p वगैरह है, तो यह const पॉइंटर(pointer) की तरफ है इसलिए पॉइंटर(pointer) स्थिर है।
 तो यह मूल अंगूठे नियम है जिसके द्वारा आप यह तय कर सकते हैं कि उनमें से कौन एक स्थिर है।
 उदाहरण नीचे दिए गए हैं।
 तो, आप इसका उपयोग कर सकते हैं और स्ट्रिंग(string) के लिए यह एक उदाहरण है कि मैंने काम किया है आप इसे ध्यान से पढ़ सकते हैं और समझने की कोशिश कर सकते हैं कि एक स्ट्रिंग(string) दी गई है और यदि हमारे पास एक स्ट्रिंग(string) है तो आप दो तरीके बदल सकते हैं जो या तो आप संपादित कर सकते हैं स्ट्रिंग(string) या आप स्ट्रिंग(string) को ही बदलते हैं।
 शीर्ष पर कोड पर हम स्ट्रिंग(string) को संपादित करने या पूरे स्ट्रिंग(string) को पूरी तरह से बदलने का प्रभाव दिखाते हैं।
 लेकिन आप रोक सकते हैं कि अगर आप कुछ ऐसा करते हैं, तो यहां एक कॉन्स्टेंट(constant) रखें, अगर आप यहां एक कॉन्स्ट(const) रखते हैं, तो स्ट्रिंग(string) खुद ही स्थिर हो जाती है, इसलिए आप स्ट्रिंग(string) के किसी भी चरित्र को नहीं बदल सकते।
 इसलिए, आप यहां ऐसा नहीं कर सकते हैं कि आप पहले प्रतीक को n लिख सकते हैं जो आप अब और नहीं कर सकते।
 जबकि, यदि आप इस तरफ कास्ट लगाते हैं तो आप अब स्ट्रिंग(string) में किसी भी चिन्ह को बदल सकते हैं, लेकिन आप स्ट्रिंग(string) को पूरे के रूप में नहीं बदल सकते।
 यहां आप स्ट्रिंग(string) बदल सकते हैं अब आप स्ट्रिंग(string) को बदल नहीं सकते क्योंकि इसका मतलब है कि पॉइंटर(pointer) को बदलना।
 और निश्चित रूप से आप दोनों के संपादन के साथ-साथ नाम के परिवर्तन की भी रक्षा कर सकते हैं यदि आप पॉइंटर(pointer) के दोनों ओर कास्ट करते हैं, तो यदि आपके पास लगातार चार वर्णों की ओर इशारा करते हुए एक चार सितारा स्टार है तो न तो इसे संपादित किया जा सकता है।
 न ही इसे बदला जा सकता है।
 यह दिखाने के लिए एक उदाहरण है कि दोनों तरफ कास्ट-नेस(ness) कैसे लागू होता है।
 इसलिए, हमने कॉन्स्ट(const)-नेस(ness) की मूल धारणा पर चर्चा की है और यह बताया है कि पॉइंटर्स के संदर्भ में कॉन्स्ट(const)-नेस(ness) कैसे लागू होता है।