Constants and Inline Functions (Contd.) (Lecture 09)-pX6LufLso2M

C ++ में प्रोग्रामिंग में फिर से एक प्रोग्रामिंग में मॉड्यूल(module) 6 में आपका स्वागत है।
 हमने इस मॉड्यूल(module) में धारणा कॉन्स्टेंस(const)-नेस(ness) पर पहले ही चर्चा की है, हमने चर्चा की है कि मैनिफ़ेस्ट कॉन्स्टेंट का उपयोग करने के स्थान पर हम एक वैरिएबल(variable) डिक्लेरेशन को क्वालिफ़ाइ करने के लिए कॉन्स्ट(const) डिक्लेरेशन का उपयोग कैसे कर सकते हैं और यह हमें एक बार वैरिएबल(variable) का मान बदलने की अनुमति नहीं देता घोषित किया गया है और आरंभिक है।
 हमने यह भी दिखाया है कि पॉइंटर्स के साथ कॉन्स्ट(const)-नेस(ness) कैसे काम करता है और पॉइंटेड डेटा(data) के निरंतर पॉइंटर एन्स कॉन्स्ट(const)-नेस(ness) के बारे में बात करता है।
 हम उस पर कायम रहेंगे।
 इसके बाद, हम संबंधित धारणा के बारे में बात करेंगे, जिसे वोलातिल(volatile) के रूप में जाना जाता है।
 यह अस्थिरता एक कम ज्ञात अवधारणा है इसलिए हमें इसे थोड़ा समझने की कोशिश करें।
 एक वैरिएबल(variable) के बारे में सोचते हैं, तो हम वैरिएबल(variable) के साथ क्या कर सकते हैं, वैरिएबल(variable) घोषित होने के बाद संभवतः आरंभिक रूप से परिभाषित किया गया है तो हम वैरिएबल(variable) के मूल्य को पढ़ सकते हैं या हम किसी भी समय एक नया मान दे सकते हैं।
 मूल संपत्ति जो हम हमेशा प्रोग्राम करते हैं, यदि मैंने वैरिएबल(variable) का मान पढ़ा है, तो यदि मैं फिर से वैल्यू पढ़ता हूं, तो मुझे उम्मीद है कि मुझे पहले वाला मान तभी मिलेगा जब तक कि बीच में कुछ नया मान असाइन नहीं किया गया है।
 इसलिए अगर मैं एक मूल्य प्रदान करता हूं और कई बार पढ़ता रहता हूं तो मुझे हमेशा वही मूल्य मिलेगा जब तक कि मैं अगला असाइनमेंट नहीं करता, ये एक वैरिएबल(variable) के पढ़ने लिखने की मूल अवधारणा है।
 अब, इस संदर्भ में const-ness को देखें।
 Const-ness में हम जो कह रहे हैं कि हमें असाइन करने की अनुमति है या उस अर्थ में केवल एक बार मूल्य को इनिशियलाइज़ किया जाता है और इसे बाद में बदलने की अनुमति नहीं है।
 इसलिए, कार्यक्रम के पूरे जीवनकाल के लिए जो मूल्य मैं इस वैरिएबल(variable) के बारे में पढ़ता हूं वह वही होगा जो कास्ट-नेस(ness) है।
 इसके विपरीत वोलातिल(volatile) कह रहा है कि यह एक वोलातिल(volatile) मान है जिसका अर्थ है कि अगर मैं समय के विभिन्न बिंदुओं पर एक वैरिएबल(variable) पढ़ता हूं तो इस बात की कोई गारंटी नहीं है कि मुझे समान मूल्य मिलेगा, मुझे अलग-अलग मूल्य मिल सकते हैं।
 इसलिए, यहां तक कि जब मैंने इसे करने के लिए कोई असाइनमेंट नहीं किया है, तो एक वोलातिल(volatile) संदर्भित करता है वोलातिल(volatile) कुछ है जो वाष्पित होता है।
 मान लीजिए, वैरिएबल(variable) का मान 5 था, आपने इसे एक बार पढ़ा था, तब आपको असाइनमेंट करने की आवश्यकता नहीं है, लेकिन आप इसे दस स्टेटमेंट्स के बाद पढ़ सकते हैं या निश्चित समय के बाद यह मान 7 पाया जा सकता है।
 इससे पहले मान 5 गायब हो गया है वाष्पित हो गया है।
 तो यह वोलातिल(volatile) वैरिएबल(variable) की धारणा है।
 प्रोग्राम में इस तरह का परिवर्तनशील व्यवहार होना क्यों महत्वपूर्ण है क्योंकि कुछ सिस्टम स्थितियां हैं जहां यह हो सकता है, उदाहरण के लिए, मैं एक नेटवर्क प्रोग्रामिंग कोड(code) लिख रहा हूं जिसका उद्देश्य खोजने के लिए एक पोर्ट को सुनना जारी रखना है, यदि कुछ डेटा(data) आ गया है।
 तो आप क्या कर रहे हैं आप से उम्मीद है कि आप उस पोर्ट पर कुछ भी लिख सकते हैं क्योंकि आप सिस्टम के बाहर से डेटा(data) की उम्मीद कर रहे हैं, इसलिए आप केवल पढ़ना, पढ़ना, पढ़ रहे हैं।
 क्या होगा? जब कुछ डेटा(data) आता है तो आपका मूल्य बदल जाएगा, लेकिन पहले जब आपने पढ़ा है कि मूल्य संभवतः शून्य था, तो अचानक आप इसे पढ़ सकते हैं 100 मिलीसेकंड के बाद आप पाते हैं कि कुछ मूल्य आ गया है, आप इसे एक और 100 मिलीसेकंड के बाद पढ़ सकते हैं।
 अलग मूल्य पर है कि आया है क्योंकि एक और अलग पैकेट आया है।
 यह संभव है कि एक वैरिएबल(variable) को हार्डवेयर द्वारा ऑपरेटिंग सिस्टम के कर्नेल द्वारा किसी अन्य थ्रेड द्वारा और इसी तरह बदला जा सकता है, इसलिए यह आवश्यक है कि उस व्यवहार को मॉड्यूल(module) किया जाए और C ++ में यह कॉन्सेप्ट के साथ संयोजन में मॉड्यूल(module) है क्योंकि एक दयालुता आपको पूर्ण सत्य प्रदान करती है और दूसरा जो आपको इस बात की गारंटी देता है कि आप यह नहीं जानते कि वैरिएबल(variable) का मूल्य क्या है।
 इसलिए वे एक साथ क्लब हैं और हमने वोलातिल(volatile), सीवी क्वालिफायर के लिए कॉन्स्टेबल वी के लिए सीवी क्वालिफायर, सी के रूप में बुलाया और एक वेरिएबल(variable) के किसी भी घोषणा को सीवी क्वालिफायर कास्ट या वोलातिल(volatile) के साथ उपसर्ग(prefix) किया जा सकता है।
 हम इसका उदाहरण दिखाएंगे।
 यहां, हम यह दिखाने की कोशिश कर रहे हैं कि कैसे वोलातिल(volatile) उपयोगी हो सकता है।
 यह एक कोड(code) बहुत ही सरल कोड(code) है जो 0 से i तक मान प्रदान करता है और फिर उस स्थिति को देखने की कोशिश करता है जो मैं 100 के बराबर नहीं है।
 अब, यदि आपने अभी यह कोड(code) दिखाया था तो आप तुरंत पहचान लेंगे कि यह एक अनंत लूप है।
 यह एक अनंत लूप क्यों है? क्योंकि यदि i का मान 0 है और तब मैं जाँच कर रहा हूँ कि क्या मैं 100 वर्ष का हूँ और जब तक मैं सौ नहीं होता तब तक मैं अचानक 100 का मान नहीं बनाऊँगा।
 इसलिए यह स्थिति हमेशा सही रहेगी इसलिए यह लूप निश्चित रूप से जारी रखें, इसलिए संकलक क्या करेगा संकलक अनुकूलन करेगा और कहेगा कि यह सच है, यह है (1) जबकि बस पूरी अभिव्यक्ति चली जाएगी।
 अब हम कहते हैं कि आप इसे एक वोलातिल(volatile) के रूप में योग्य बनाते हैं।
 आप कहते हैं कि यह एक वोलातिल(volatile) वैरिएबल(variable) i है और आप उसी कोड(code) को पढ़ते हैं जो अब न तो ऑप्टिमाइज़ होता है और न ही आपको उम्मीद है कि यह कोड(code) वास्तव में काम करेगा क्योंकि एक वोलातिल(volatile) वैरिएबल(variable) होने के नाते आप उम्मीद करते हैं कि कुछ अन्य एजेंट हैं, कुछ हार्डवेयर हैं, कुछ पोर्ट, कुछ कर्नेल प्रणाली, कुछ धागा संभवतः किसी अन्य माध्यम से बदल रहा है।
 तो, आप तब तक प्रतीक्षा करते रहते हैं जब तक कि इसका मूल्य 100 नहीं हो जाता और यह संभव है कि किसी समय यह 100 हो जाए और फिर यह कि कोई विशेष स्थिति झूठी हो जाए और फ़ंक्शन(function) वापस आ सकेगा।
 यह C, C ++ में वोलातिल(volatile) वैरिएबल(variable) का उपयोग है।
 चलिए अब हम चलते हैं और #define के लिए एक अलग तरह के उपयोग के बारे में बात करते हैं, जिसे फिर से cp प्रोसेसर(processor) द्वारा संसाधित किया जाता है जिसे हम मैक्रोज़(macros) कहते हैं।
 अंतर यह है कि हम अभी भी उन्हें एक # शब्द के साथ परिभाषित करते हैं जिसका हमारे पास एक नाम है, लेकिन मुख्य बात यह है कि अब हमारे पास इस में एक पैरामीटर(parameter) है।
 तो क्या होता है जब मैं उपयोग करता हूं, तो मैं इसे मापदंडों के साथ उपयोग करता हूं इसलिए हम कह रहे हैं कि एक वर्ग परिभाषित नाम है और मैं इसे एक पैरामीटर(parameter) डाल रहा हूं जिसका प्रभाव है, सी प्रीप्रोसेसर सीधे चले जाएंगे, एक्स के साथ मैच करेंगे और सभी एक्स को परिभाषित अभिव्यक्ति में ए से बदलें।
 यह सरल एक्स बेस प्रतिस्थापन है।
 इसलिए, जहाँ भी यह एक्स को उस एक्सप्रेशन में मिलेगा, इसे पैरामीटर(parameter) ए के साथ बदल देगा।
 अब, मैक्रोज़(macros) को आमतौर पर C में चित्रित किया जाता है और C ++ में भी उपयोगी होता है, लेकिन यह हमें नोटेशन जैसे फ़ंक्शन(function) को लिखने की अनुमति देता है।
 इसलिए अगर आपको #define लाइन को नहीं बताया गया है और यदि आप मुख्य को पढ़ रहे हैं तो आपको पता नहीं चलेगा कि वर्ग कहाँ स्थूल है या यह एक ऐसा कार्य है जो बहुत अच्छी तरह से एक फ़ंक्शन(function) हो सकता है।
 लेकिन जब यह संकलक के पास आता है, तो फिर से प्रकट होने के मामले में जैसे कंपाइलर यह नहीं देख पा रहा था कि यह एक वैरिएबल(variable) है, यह केवल उस निरंतर मूल्य को देख रहा है जिसे आपने लिखा है या आपके द्वारा लिखी गई निरंतर अभिव्यक्ति है, यहाँ फिर से संकलक किसी भी प्रकार के फ़ंक्शन(function) संकेतन को नहीं देख पाएगा, वह बस उस अभिव्यक्ति को देख पाएगा जिसे CPP ने प्रतिस्थापित किया है।
 इसलिए मैक्रोज़(macros) का सी प्रोग्रामिंग में बहुत बार व्यापक रूप से उपयोग किया गया है और इसमें विशेष रूप से सी में ऐसे फायदे हैं जो आप मैक्रोज़(macros) के बिना कई कारणों से नहीं कर सकते थे।
 यह आपको दक्षता भी प्रदान करता है क्योंकि मैक्रोज़(macros) को इसके ऊपर एक फ़ंक्शन(function) की आवश्यकता नहीं है, लेकिन उनके पास एक बहुत गंभीर नुकसान भी है।
 हम यहां कुछ चौपाइयों को एक ही वर्ग उदाहरण में दिखाते हैं और हम कोशिश कर रहे हैं, यह एक मैक्रो है और यहां मैं इसे +1 के साथ उपयोग करने का प्रयास कर रहा हूं।
 इससे पहले, मैं इसका उपयोग कर रहा था, मैं इसे +1 का उपयोग करने की कोशिश कर रहा हूं, निश्चित रूप से अगर कोई इसे पढ़ता है तो मानसिक धारणा होगी, 1 जोड़ा जाएगा, इसलिए यह 4 हो जाएगा और फिर इसे चुकता किया जाएगा, इसलिए यह होगा 16 बन जाइए।
 लेकिन, जब आप इस कार्यक्रम को चलाते हैं तो हम वास्तव में एक आउटपुट 7 प्राप्त करेंगे और यह समझने के लिए कि आपको मैक्रो का विस्तार करना होगा, अब इस मैक्रो का विस्तार इस लाइन तक करें।
 आप देख सकते हैं कि मैक्रो x को a+ 1 से बदल दिया जाता है, इसलिए यदि आप केवल a + 1 लिखते हैं तो x के स्थान पर यह a+ 1 * a +1 हो जाता है और फिर यह एक अभिव्यक्ति बन जाती है जो पूर्वता और सहानुभूति लागू होती है।
 तो, 1 में 1 बार `a’ जो कि बीच में है, को पूर्ववर्तीता मिलती है ताकि पहले एक संचालित हो, इसलिए यह व्यावहारिक रूप से 2a + 1 हो जाता है।
 इसलिए यह 7 हो जाता है, तो निश्चित रूप से यह सारी समस्या का कारण बनता है।
 सौभाग्य से, यह समस्या जो तय की जा सकती है, यदि आप केवल पैरामीटर(parameter) को हर एक्स के आसपास या मैक्रो परिभाषा में पैरामीटर(parameter) के हर उदाहरण के आसपास डालते हैं, यदि आप ऐसा करते हैं, तो यह कैसे मदद करेगा? हम केवल विस्तार देख सकते हैं, यह मदद करेगा, चूंकि कोष्ठक डाल दिया गया है, मैक्रो का विस्तार होने के बाद, इस स्लाइड की अंतिम पंक्ति में आप देख सकते हैं कि + 1 के आसपास कोष्ठक है।
 तो, यह कहते हैं (a + 1) * (a + 1) अब BODMAS नियम कहता है कि a + 1 को पहले वही होना चाहिए जो हमने उम्मीद की थी, इसलिए यह अभी भी तय किया जा सकता है।
 हमें आगे जाने दो।
 यह वास्तव में परेशान करने वाला है कि अगर आपको याद रखना है कि हर बार जब आप x लिखते हैं, तो आपको उसके चारों ओर कोष्ठक लगाना होगा अन्यथा आप आश्चर्यचकित हो सकते हैं।
 इसके बाद, एक उदाहरण देखते हैं जहां स्थिति वास्तव में बदतर है, क्योंकि, अब हमने स्थूल की परिभाषा तय कर ली है अब हम इसे फिर से उपयोग करने की कोशिश कर रहे हैं और मैं इसे ++ ए के साथ उपयोग करना चाहता हूं, एक प्लस प्लस एक पूर्व है को बढ़ा देते।
 यदि a 3 है, तो यहाँ के रूप में अगर प्लस प्लस I 4 बनने की उम्मीद है, तो 4 को वर्ग में जाना चाहिए, इसे चुकता करना चाहिए यह 4 गुना हो जाना चाहिए 4 यह परिणाम 16 होना चाहिए।
 आप कोशिश करें कि परिणाम 25 है।
 क्यों ? फिर से इस मैक्रो के विस्तार पर गौर करें, अगर इसे विस्तारित किया जाता है तो यह इस तरह दिखता है, क्योंकि दो एक्स हैं इसलिए ++ ए, उनमें से प्रत्येक के लिए लिखा गया है।
 तो क्या होता है, ++ में सबसे अधिक पूर्वता अधिक होती है, गुणन की तुलना में अधिक पूर्वता होती है, इसलिए गुणन के घटित होने से पहले प्लस और प्लस दोनों हुआ है, a 3 पहले 4 था फिर यह 5 हो जाता है और फिर गुणन होता है।
 इसलिए परिणाम अपेक्षित रूप से 25 है।
 कहानी का दुर्भाग्यपूर्ण हिस्सा सी में इसके लिए कोई आसान निर्धारण नहीं है।
 इसलिए, आपको मैक्रोज़(macros) में इन प्रकार के संभावित नुकसानों के साथ रहना होगा।
 इसलिए, C ++ में एक नई सुविधा है जिसे इनलाइन(inline) फ़ंक्शन(function) कहा जाता है।
 मुझे पहले यह परिभाषित करना है कि यह कैसे करना है और फिर हम बताएंगे कि यह मैक्रोज़(macros) से कैसे संबंधित है? एक इनलाइन(inline) फ़ंक्शन(function) केवल एक अन्य फ़ंक्शन(function) है कोई विशेष प्रकार का फ़ंक्शन(function) केवल अंतर नहीं है, हेडर में फ़ंक्शन(function) के प्रोटोटाइप(prototype) में आप अगला लिखते हैंवापसी प्रकार से पहले इनलाइन(inline) का योग करें।
 इसलिए यदि आप इस कीवर्ड इनलाइन(inline) को लिखते हैं तो तब क्या होता है जब फ़ंक्शन(function) को वास्तविक फ़ंक्शन(function) कॉल कहा जाता है, लेकिन ऐसा नहीं होता है, लेकिन जो भी फ़ंक्शन(function) फ़ंक्शन(function) कोड(code) को संकलक कॉल साइट पर डालता है वह मूल है।
 इसलिए, फ़ंक्शन(function) की ओवर रेट कॉल टाल दी जाती है, इसलिए, हम फ़ंक्शन(function) को परिभाषित करते हैं, हम फ़ंक्शन(function) हेडर को इनलाइन(inline) के साथ उपसर्ग(prefix) करते हैं यह सिर्फ दाहिने हाथ की तरफ ध्यान केंद्रित करता है जो कि C ++ कोड(code) छोड़ दिया गया है हाथ की ओर दाहिने हाथ की तरफ आपके संदर्भ का मूल C कोड(code) है जो हमने हैश डिफाइन मैक्रो नहीं कर रहे हैं हम कह रहे हैं कि स्क्वायर एक फ़ंक्शन(function) है जो x रिटर्न x को एक पूर्णांक के रूप में लेता है और हम इनलाइन(inline) कीवर्ड के साथ इसे प्रीफ़िक्स कर रहे हैं सामने।
 इसके लिए और यहाँ उपयोग कोड(code) समान रहता है।
 अब, लाभ यह है कि C ++ में, यह वास्तव में एक फ़ंक्शन(function) है।
 इसलिए आपके पास ऐसा कोई भी नुकसान नहीं हो सकता है जो हम पहले दिखा रहे थे जो पहले बहुत ही सही मायने में पैरामीटर(parameter) का मूल्यांकन करता है और फिर उस मूल्यांकन मूल्य को लेता है और फ़ंक्शन(function) को कॉल करता है।
 तो अगर आप यहाँ + 1 पास करते हैं तो यह पहले 1 को 4 बना देगा और फिर पास कर देगा, अगर आप ++a करते हैं तो यह 3 से 4 तक बढ़ जाएगा और पास हो जाएगा।
 इसलिए, आपको कोई नुकसान नहीं होने वाला है।
 लेकिन आपको मैक्रो का फायदा मिलता है जो हैश डिफाइन मैक्रोज़(macros) के साथ होता है जिसे आप फंक्शन के ओवर हेड से बचने में सक्षम थे, सभी पैरामीटर(parameter) कोपिंग कहते हैं, फिर कंट्रोल ट्रांसफर, फिर कंप्युटेशन और फिर कंट्रोल ऑफ और ट्रांसफर बैक।
 रिटर्न वैल्यू के कारण यह सब टल सकता है क्योंकि कंपाइलर वास्तव में एक्स बार एक्स को लगाने की कोशिश करेगा जो मैं यहां कर रहा हूं साइट पर फंक्शन को बुलाया गया है।
 तो, यह इनलाइनिंग(inlining) की मूल विशेषता है।
 इसलिए इनलाइनिंग(inlining) से मैक्रो का लाभ काफी हद तक प्राप्त करने में मदद मिलती है, जबकि यह मूल गुणों और कार्यों के प्रकारों की रक्षा करता है।
 अगर हम बस उनकी ओर से तुलना कर सकते हैं, तो मैक्रोज़(macros) का विस्तार किया जाता है जिसे इनलाइन(inline) के स्थान पर विस्तारित किया जाता है, किसी तरह कॉल की जगह का विस्तार किया जाता है।
 लेकिन आपको यह दिखाना संभव नहीं है क्योंकि मैक्रो का विस्तार टेक्स्ट रूप में किया जाता है, इसलिए मैं आपको यह समझा सकता हूं, लेकिन इनलाइन(inline) फ़ंक्शन(function) को असेंबली कोड(code) या बाइनरी कोड(code) के संदर्भ में विस्तारित किया जाता है, इसलिए यह समझना संभव नहीं है यह इतनी आसानी से है, लेकिन हम कर सकते हैं बस यह ले सकते हैं कि यह उस साइट का काम करता है जिसे आपने बुलाया था।
 निष्पादन में दोनों कुशल हैं और दोनों ही कोड(code) को ब्लोट करते हैं।
 कोड(code) फ़र्स्ट हो जाता है, क्योंकि क्या हो रहा है कि आपके पास एक फ़ंक्शन(function) परिभाषित है और यदि आप एक मैक्रो कर रहे हैं जो कि मैक्रो को 10 स्थानों पर लागू कर सकता है, तो पूरे मैक्रो कोड(code) को दस बार कॉपी किया जाएगा।
 इसी तरह, इनलाइन(inline) फ़ंक्शन(function) यदि मेरे पास फ़ंक्शन(function) इनलाइन(inline) है और जिसे दस स्थानों पर बुलाया गया है, तो फ़ंक्शन(function) बॉडी दस स्थानों पर होगी इसलिए कोड(code) बड़ा हो जाएगा।
 हो सकता है कि हम कुछ सॉफ्ट कॉमन सॉफ्टवेयर सिस्टम के लिए चिंता न करें, लेकिन हम अन्य मामलों में एक चिंता का विषय हो सकते हैं जैसे कि जब हम मोबाइल फोन के लिए प्रोग्राम लिखते हैं और उपकरणों को हैंडल करते हैं तो मेमोरी वास्तव में छोटी होती है यदि प्रोग्राम बड़ा हो जाता है तो उस ऐप को फिट करना मुश्किल हो जाता है, क्योंकि आप ऐप के आकार से भी चिंतित हैं।
 लेकिन हम इसमें ज्यादा गहरे नहीं उतरेंगे।
 अगला बिंदु यह है कि मैक्रोज़(macros) में सिंटैक्टिक और सिमेंटिक नुकसान होते हैं जिन्हें हमने उनमें से दो दिखाए हैं, a + 1 एक सिंटैक्टिक ख़राबी थी इसलिए हम इसे उनके चारों ओर कोष्ठक लगाकर प्रबंधित कर सकते थे, ++a सिंटैक्टिक ख़राबी थी क्योंकि जिस तरह से प्लस है निष्पादित किया गया, इसलिए हम यह प्रबंधन नहीं कर सके कि हमें इसे छोड़ना होगा, लेकिन इनलाइन(inline) फ़ंक्शन(function) में ऐसी कोई कमी नहीं होगी।
 निश्चित रूप से मैक्रोज़(macros) मापदंडों के लिए प्रकारों की जांच नहीं करते हैं, जैसा कि इनलाइन(inline) फ़ंक्शन(function) करते हैं।
 इसलिए, उनके पैरामीटर(parameter) मजबूत हैं, इसलिए यह संभव है कि एक मैक्रो जो जानबूझकर एक पूर्णांक प्रकार के मान के लिए लिखा गया हो, अनजाने में कुछ दोहरे वैरिएबल(variable) के साथ कॉल या आमंत्रित किया जा सकता है, संकलक समझ नहीं पाएगा, जबकि इनलाइन(inline) फ़ंक्शन(function) ऐसा नहीं है यह संभव है क्योंकि यह सिर्फ हमारे पास होने वाला कार्य है।
 हालांकि, मेरे मैक्रों के पास उदाहरण के लिए फायदे हैं, यह तथ्य कि यह प्रकार के लिए जांच नहीं करता है, हमें कुछ कोड(code) लिखने में मदद करता है मुझे पता नहीं था कि टाइप क्या है।
 उदाहरण के लिए, मैं दो वैरिएबल(variable) स्वैप करने के लिए एक कोड(code) लिखना चाहता हूं।
 अब, दो वैरिएबल(variable) को स्वैप करने के लिए कोड(code) इंट वैरिएबल(variable) को स्वैप कर सकता है, दोहरे वैरिएबल(variable) को स्वैप कर सकता है, char वैरिएबल(variable) को स्वैप कर सकता है और इसी तरह।
 लेकिन अगर आपको C ++ में लिखना है, तो स्वैप फंक्शन, एक स्वैप फंक्शन यह सब नहीं कर सकता क्योंकि अगर मुझे दो int वैरिएबल(variable) स्वैप करने हैं तो मेरे पैरामीटर(parameter) int टाइप के होंगे, अगर मैं दो डबल वैरिएबल(variable) स्वैप करना चाहता हूं तो मेरे पैरामीटर्स दो प्रकार के होंगे, अगर मैं दो बिंदुओं को स्वैप करना चाहता हूं तो मेरे पैरामीटर(parameter) सूचक प्रकार के होंगे।
 इसलिए मैं उस फ़ंक्शन(function) को C ++ में आसानी से नहीं लिख सकता, और इनलाइन(inline) को।
 जबकि, मैं एक मैक्रो लिख सकता था और इसे स्वैप कर सकता था क्योंकि मैक्रो उस प्रकार की जाँच नहीं कर रहा है, यह सिर्फ यह जाँच करेगा कि दो वैरिएबल(variable) और तीसरे वैरिएबल(variable) तीन असाइनमेंट हैं जिन्हें हम जानते हैं कि स्वैप कैसे करना है यह सिर्फ उस कोड(code) को यहां रखा जाएगा।
 तो, मैक्रोज़(macros) कुछ फायदे प्रदान करते हैं और पाठ्यक्रम के अंत की ओर आगे बढ़ते हुए हम दिखाएंगे कि आप इनलाइन(inline) फ़ंक्शंस के साथ भी कर सकते हैं, लेकिन टेम्पलेट के रूप में ज्ञात C ++ की बहुत बाद की सुविधाओं के समर्थन के साथ; जब आप चर्चा करेंगे कि हम यह दिखाएंगे कि यह कैसे होता है।
 अंत में, मैक्रोज़(macros) के लिए इनलाइन(inline) फ़ंक्शन(function) के संकलन के लिए कोई त्रुटि जाँच नहीं की गई है, त्रुटियों की जाँच की जाती है और निश्चित रूप से मैनिफ़ेस्ट निरंतर मैक्रोज़(macros) भी डिबगर के लिए दृश्यमान नहीं होते हैं।
 यदि आप डीबग करने का प्रयास करते हैं तो आप वर्ग मैक्रो नहीं देख पाएंगे क्योंकि वास्तव में कंपाइलर ने उस वर्ग को कभी नहीं देखा है क्योंकि इसे पूर्व प्रोसेसर(processor) द्वारा प्रतिस्थापित किया गया था।
 जबकि, इनलाइन(inline) फ़ंक्शन(function) के लिए आप डिबग बिल्ड में वह सब देख पाएंगे।
 यदि आप डिबग बिल्ड करते हैं तो आप वह देख पाएंगे।
 अंतर जो मुझे यहां उजागर करना चाहिए, कि इनलाइन(inline) फ़ंक्शन(function) 1 सुविधा के साथ जो कंपाइलर करता है यदि आप डिबग बिल्ड करते हैं, तो इनलाइनिंग(inlining) नहीं किया जाता है, यदि आप एक रिलीज़ बिल्ड करते हैं तो इनलाइनिंग(inlining) किया जाता है।
 यदि आप डिबग बिल्डिंग करते हैं तो इनलाइन(inline) फ़ंक्शन(function) किसी अन्य फ़ंक्शन(function) की तरह होता है, इसलिए आप उस फ़ंक्शन(function) में डीबग कर सकते हैं।
 क्योंकि डिबग बिल्ड में आप कह रहे हैं कि मैं डिबग करना चाहता हूं मैं अंदर देखना चाहता हूं कि क्या हो रहा है जबकि, एक रिलीज या प्रोडक्शन बिल्ड में आप वास्तव में दक्षता चाहते हैं, आप चाहते हैं कि कोड(code) सबसे तेज चलना चाहिए।
 तो, आप किसी भी अधिक डिबग करने के लिए इच्छुक नहीं हैं आप पहले से ही डिबग करते हैं आप जानते हैं कि यह सही है, कि जब इनलाइनिंग(inlining) वास्तव में होती है, तो यह थोड़ा सूक्ष्म बिंदु होता है, लेकिन कृपया ध्यान रखें कि समय के साथ आप इन कारकों को धीरे-धीरे समझेंगे।
 ।
 इसलिए, हम आपको सुझाव देंगे कि आप हमेशा इनलाइनिंग(inlining) का उपयोग करें।
 हालाँकि कुछ सीमाएँ हैं जिनके बारे में आपको अवगत होना चाहिए।
 इनलाइनिंग(inlining) को एक निर्देश कहा जाता है।
 किसी भाषा में एक निर्देश संकलक को एक सुझाव है, आप संकलक को बता रहे हैं मुझे लगता है कि यह इस फ़ंक्शन(function) को इनलाइन(inline) करने के लिए उपयोगी है, लेकिन यह अनिवार्य नहीं है, यह संकलक पर बाध्यकारी नहीं है, यह इनलाइन(inline) होना चाहिए।
 तो आपको इनलाइन(inline) कहना होगा, लेकिन कंपाइलर फ़ंक्शन(function) को इनलाइन(inline) नहीं कर सकता है।
 यदि कंपाइलर पाता है कि इनलाइनिंग(inlining) में समस्या है या इसे इनलाइन(inline) करने से वास्तव में दक्षता में मदद नहीं मिलती है।
 उदाहरण के लिए जैसा कि बहुत ही सरल उदाहरण है, यदि कोई फ़ंक्शन(function) बॉडी बहुत बड़ी है, तो आप फिर से इनलाइनिंग(inlining) करके क्या कर रहे हैं कि फ़ंक्शन(function) कॉल की आवश्यकता नहीं है फ़ंक्शन(function) को लिखने की आवश्यकता नहीं है, बाकी की गणना किसी भी तरह से की जानी है।
 यदि फ़ंक्शन(function) बॉडी बहुत बड़ी है, तो कॉल और रिटर्न का अतिरिक्त ओवर रेट बहुत छोटा है, इसलिए आप इनलाइन(inline) इनलाइनिंग(inlining) की इस परेशानी को प्राप्त नहीं करना चाहते हैं, लेकिन यदि फ़ंक्शन(function) बॉडी बहुत छोटी है, तो इनलाइनिंग(inlining) वास्तविक है।
 संकलक तय करता है कि वह इनलाइनिंग(inlining) करना चाहता है या नहीं।
 कई मामलों में, C ++ में रिवर्स भी सच है कि आपने यह नहीं कहा होगा कि कोई फ़ंक्शन(function) इनलाइन(inline) हो सकता है, लेकिन कंपाइलर इसे इनलाइन(inline) कर सकता है और यह पता लगा सकता है कि यह इनलाइन(inline) में कुशल है।
 दूसरी बात यह है कि इनलाइन(inline) फ़ंक्शन(function) पुनरावर्ती नहीं हो सकते हैं।
 हम जो कह रहे हैं, हम कह रहे हैं कि इनलाइन(inline) के स्थान पर, फंक्शन कॉल के चरण में हम फंक्शन की बॉडी को डालेंगे यदि कोई फंक्शन रिकर्सिव होता है तो बॉडी में ही दूसरा कॉल होता है।
 तो, उस कॉल पर आपको फिर से फंक्शन की बॉडी रखनी होगी, जिसमें दूसरा कॉल होगा।
 अब आप इसे कितनी बार डालेंगे जो इस बात पर निर्भर करता है कि पुनरावृत्ति कितनी गहराई तक चली जाती है जिसे आप तब तक नहीं जानते जब तक आपके पास मूल्य नहीं हैं, जब तक आप जानते हैं कि क्या आप फैक्टोरियल 3 करने की कोशिश कर रहे हैं या आप फैक्टोरियल 77 करने की कोशिश कर रहे हैं।
 इनलाइनिंग(inlining) को कितनी बार होना है, इसलिए रिकर्सन फ़ंक्शन(function) इनलाइन(inline) नहीं हो सकता है, उन्हें आवश्यक रूप से एक सामान्य फ़ंक्शन(function) होना चाहिए।
 चूंकि, इनलाइनिंग(inlining) शरीर की जगह ले रही है।
 तीसरे बिंदु में मैं इस तथ्य को उजागर करता हूं कि यदि आप फ़ंक्शन(function) को इनलाइन(inline) करना चाहते हैं, तो फ़ंक्शन(function) बॉडी को हेडर फ़ाइल में भी होना होगा।
 पहले मॉड्यूल(module) 1 में हमने स्रोत संगठन के बारे में बात की है, जहां उन्होंने कहा है कि सभी फ़ंक्शन(function) हेडर प्रोटोटाइप(prototype) होना चाहिए हेडर फ़ाइलों में होना चाहिए, डॉट एच फाइलें फ़ंक्शन(function) बॉडी कार्यान्वयन अलग डॉट सीपीपी फ़ाइलों में होना चाहिए, लेकिन इनलाइन(inline) फ़ंक्शन(function) के लिए यह नहीं है संभव है क्योंकि जब कोई एप्लिकेशन फ़ंक्शन(function) प्रोटोटाइप(prototype) को देखता है जब तक कि वह यह नहीं देख सकता कि यह इनलाइन(inline) कैसे करता है, यह शरीर को कैसे प्रतिस्थापित करता है।
 तो इनलाइन(inline) फ़ंक्शन(function) के लिए शरीर को हेडर में होना चाहिए।
 निश्चित रूप से इनलाइन(inline) फ़ंक्शंस में दो अलग-अलग परिभाषाएँ नहीं होनी चाहिए क्योंकि इसमें दो अलग-अलग परिभाषाएँ हैं तो दो इनवोकेशन में दो अलग-अलग व्यवहार होंगे।
 तो, ये इनलाइनिंग(inlining) की कुछ सीमाएँ या प्रतिबंध हैं जिन्हें ध्यान में रखना आवश्यक है।
 सारांश में, हमने C के लिए प्रकट स्थिरांक पर दोबारा गौर किया है; मैं पूरे मॉड्यूल(module) 6 के बारे में बात कर रहा हूं।
 इसलिए, हमने प्रकट स्थिरांक पर फिर से गौर किया है और हमने कास्ट-नेस(ness) की धारणा को समझ लिया है जैसा कि C ++ में उपलब्ध है और हमने देखा है, प्रकट स्थिरांक पर कब्ज के क्या फायदे हैं।
 हमने यह भी देखा है कि कैसे कास्ट और पॉइंटर इंटरप्ले करते हैं।
 हमने डेटा(data) की अस्थिरता के लिए धारणा पेश की है और देखा है कि C ++ प्रोग्राम में वोलातिल(volatile) डेटा(data) का उपयोग कैसे किया जा सकता है।
 अगला, हमने पैरामीटर(parameter) फॉर्म सी के साथ मैक्रोज़(macros) को फिर से परिभाषित किया है और दिखाया है कि इनलाइन(inline) फ़ंक्शन(function) या फ़ंक्शन(function) इनलाइनिंग(inlining) का उपयोग मैक्रोज़(macros) के स्थान पर लाभ के साथ किया जा सकता है जो कि मैक्रोज़(macros) ऑफ़र के कई सिंटैक्टिक और सिमेंटिक समस्याओं को हल करता है।
 अंत में, हमने इनलाइन(inline) पर प्रतिबंधों को भी देखा है।