C ++ में प्रोग्रामिंग के मॉड्यूल(module) 7 में आपका स्वागत है।
 हम C ++ में C के प्रक्रियागत विस्तार पर चर्चा करना जारी रखेंगे।
 हमने मॉड्यूल(module) 6 में पेश किया है और सीवी-क्वालिफायर(cv-qualifier), स्थिर(constant) और वाष्पशील(volatile) क्वालिफायर(qualifier) और इनलाइन कार्यों के उपयोग की दो बुनियादी अवधारणाओं पर चर्चा की है।
 इस मॉड्यूल(module) में, हम एक और कॉन्सेप्ट पेश करेंगे, जिसे संदर्भ(reference) कहा जाता है।
 संदर्भ(reference) की यह अवधारणा निकट से संबंधित है, लेकिन सूचक(pointer) की अवधारणा से बहुत अलग है।
 तो, हम भी करेंगे; जैसा कि हम मॉड्यूल(module) से गुजरते हैं, हम संदर्भ(reference) और पॉइंटर(pointer) के बीच तुलना और इसके विपरीत प्रयास भी करेंगे।
 इसलिए, उनका उद्देश्य संदर्भ(reference) को समझना और इस विपरीत को समझना है।
 ये विभिन्न विशिष्ट विषय हैं, जिनसे हम गुजरेंगे।
 एक संदर्भ(reference) एक उपनाम(alias)(alias) की तरह है या एक मौजूदा चर(variable) का एक पर्याय है।
 इसलिए, उपनाम(alias) हमारे अपने नामों के संदर्भ(reference) में है।
 हमारा कुछ नाम है।
 हमारे पास कुछ पालतू नाम हैं और हमें संदर्भित किया जा सकता है, इसे नामों में से किसी भी नाम से जाना जाता है।
 तो, यहाँ संदर्भ(reference) चर(variable) का भी यही उद्देश्य है।
 तो, मैं एक चर(variable) है जिसे घोषित किया गया है।
 यहां इसे 15 से शुरू किया गया है और इस संदर्भ(reference) में हमारे पास एक चर(variable) i है, जिसे परिभाषित किया गया है।
 इसका एक प्रारंभिक मूल्य है 15 अब, मैं एक और चर(variable) को परिभाषित करता हूं और विशेष रूप से यहां & प्रतीक के इस उपयोग को देखता हूं।
 हम एक वैरिएबल(variable) जे को परिभाषित करते हैं और इसे इनिशियलाइज़ करते हैं।
 इस तरह के वेरिएबल(variable)(variable) j को i का संदर्भ(reference) या i के लिए एक रेफरेंस वेरिएबल(variable)(variable) कहा जाता है।
 तो, यह संदर्भ(reference) चर(variable)(variable) वास्तव में i के लिए एक वैकल्पिक नाम और उपनाम(alias) नाम है।
 इसलिए, यदि मैं मेमोरी(memory) में देखता हूं, तो मैं और जम्मू दोनों वास्तव में एक ही मेमोरी(memory) लोकेशन का प्रतिनिधित्व करेंगे।
 इसलिए, यदि मेरे पास मेमोरी(memory) एड्रेस 200 है, जैसा कि मैं नीचे दिखाता हूं कि अगर यह i का पता है और इसकी सामग्री 15 है, तो j का पता भी 200 होगा, i का 200।
 तो, यह इसके बाद सारहीन है, यह विशेष संदर्भ(reference) जे पेश किया गया है यह इस बात के लिए सारहीन है कि क्या मैं i को i के रूप में संदर्भित करता हूं या मैं i को j के रूप में संदर्भित करता हूं।
 यह एक संदर्भ(reference) की मूल अवधारणा है।
 इसलिए, आइए संदर्भ(reference) के व्यवहार को समझने के लिए एक छोटे से कार्यक्रम पर ध्यान केंद्रित करें।
 इस कार्यक्रम में, मैं आपको दिखाऊंगा, एक चर(variable) है और बी को एक संदर्भ(reference) के रूप में सेट किया गया है।
 फिर अगले दो आउटपुट(output) स्टेटमेंट्स में, हम सबसे पहले a और b का मूल्य प्रिंट(print) करते हैं।
 हम यहाँ आउटपुट(output) देख सकते हैं; 10 और 10; क्योंकि 10 और b एक का एक उपनाम(alias) है।
 इसलिए, अगर मैं बी प्रिंट(print) करता हूं, तो भी मैं 10 प्रिंट(print) करूंगा।
 और कॉट की दूसरी लाइन में, हम प्रिंट(print) करते हैं कि यहां लाइन है।
 हम a का पता प्रिंट(print) करते हैं, और हम b का एड्रेस प्रिंट(print) करते हैं।
 ये पते(address) हैं जो इस लाइन को प्रिंट(print) कर रहे हैं।
 हम फिर से जाँच सकते हैं कि वे समान पते(address) हैं।
 कि वे वास्तव में एक ही चर(variable) हैं, बस वे दो अलग-अलग नाम हैं।
 तो, चलिए वेरिएबल(variable) के मान को बदलने का प्रयास करते हैं।
 तो, यहाँ हम एक वृद्धि करते हैं, और फिर इसे फिर से आउटपुट(output) करते हैं।
 अगर हम एक वृद्धि करते हैं, तो यह 11 हो जाएगा, इसलिए आप यहां देख सकते हैं कि ए, 11 हो गया है और बी, भले ही अब ऑपरेशन बी के साथ किया गया था, बी भी ग्यारह बन गया है।
 और, आप इसे अन्य तरीके से भी कर सकते हैं।
 यदि आप b वृद्धि करते हैं, तो b 12. बन जाता है और a, जिस चर(variable) को b सन्दर्भ दिया जाता है, वह भी बन गया है 12. अर्थात, वे बहुत दृढ़ता से एक साथ युग्मित होते हैं और किसी एक का उपयोग दूसरे के उद्देश्य के लिए किया जा सकता है।
 तो, यह मूल गति है।
 अब, निश्चित रूप से यदि आप ऐसा करने की कोशिश करते हैं, तो आपको सावधान रहना होगा कि कुछ बहुत ही विशिष्ट नुकसान हैं जो आप अपने आप में प्राप्त कर सकते हैं।
 इसलिए, तीन सामान्य नुकसान मैं यहाँ स्पष्ट करता हूं; यह अधिक हो सकता है।
 यही है, अगर हम सिर्फ एक संदर्भ(reference) को परिभाषित करने की कोशिश करते हैं, लेकिन एक चर(variable) के साथ इसे शुरू किए बिना।
 फिर, संकलक आपको एक त्रुटि देगा क्योंकि एक संदर्भ(reference) कुछ अन्य चर(variable) के लिए एक उपनाम(alias) है।
 इसलिए, जब तक आप इसके साथ एक चर(variable) को परिभाषित नहीं करते हैं, तब तक इसके साथ एक चर(variable) को इनिशियलाइज़ करें, जिसका संदर्भ(reference) लेने के लिए कोई संदर्भ(reference) नहीं है।
 इसलिए, यह गलत है।
 इसलिए, यदि आप केवल तालिका पर देखते हैं, तो बाईं ओर मैं गलत घोषणा दिखाता हूं और सबसे दाईं ओर मैं इसी सही संस्करण को दिखाता हूं, और आप दिए गए कारण को समझ सकते हैं।
 अगर मैं अगले एक को देखता हूं, यानी अगर मैं यहां देखता हूं, तो आप एक निरंतर मूल्य का संदर्भ(reference) देने की कोशिश कर रहे हैं।
 यह भी एक त्रुटि है क्योंकि एक स्थिर मूल्य सिर्फ एक मूल्य है।
 इसके पास निवास करने के लिए कोई पता नहीं है।
 इसलिए, आपके पास किसी मान का संदर्भ(reference) नहीं हो सकता है, लेकिन आपके पास मान के लिए एक निरंतर संदर्भ(reference) हो सकता है; क्योंकि यह एक निरंतर मूल्य है।
 इसलिए, संदर्भ(reference) को भी एक स्थिर होना होगा।
 अन्यथा, आप उस खतरे के बारे में सोच सकते हैं जो होगा; यह खतरनाक से संबंधित है जैसा कि हमने सहमति में दिखाया था।
 कि अगर मैं, अगर यह सही थे, तो मान लें कि यह सही था, तो j 5 है।
 अब, अगर मैं ++ j करता हूं तो क्या होगा? जो भी इसका जिक्र कर रहा है वह बढ़ जाएगा।
 तो, यह बन जाएगा; इसलिए, एक स्थिर 5 एक स्थिर 6 बन जाएगा, जो संभव नहीं है।
 इसलिए, इसे एक const के रूप में परिभाषित किया गया है, ताकि आप उसमें कोई बदलाव न कर सकें।
 इसी तरह, अगले एक में यदि आप यहां देखें तो मेरे पास अभिव्यक्ति j + k है।
 और, मैं उसी का संदर्भ(reference) बनाने की कोशिश कर रहा हूं।
 लेकिन, फिर से अभिव्यक्ति का कोई पता नहीं है।
 J + k की गणना केवल एक अस्थायी स्थान के रूप में संग्रहीत की जाती है और उन अस्थायी स्थानों को बनाए नहीं रखा जाता है।
 इसलिए, फिर से मैं उसका संदर्भ(reference) नहीं बना सकता।
 यदि मैं एक संदर्भ(reference) रखना चाहता हूं, तो उस संदर्भ(reference) को एक स्थिर होना होगा, जो संदर्भ(reference) के मूल्य के रूप में गणना के रूप में j + k के मूल्य को संदर्भित करेगा।
 इसलिए, आप इसे बदल नहीं पाएंगे क्योंकि अभिव्यक्ति j + k को बदला नहीं जा सकता है।
 इसलिए, अगर मैं बनाता हूं; यदि हम एक संदर्भ(reference) की अनुमति देते हैं, तो हम उसे बदल पाएंगे; जो शब्दार्थिक रूप से मान्य नहीं है, यदि संदर्भ(reference) अभिव्यक्ति के लिए बनाया जा रहा है।
 तो, आप यह सब कह सकते हैं।
 इस समय, j + k का कुछ मूल्य था; जिसे एक स्थिरांक के रूप में माना जाता है।
 और, मेरे पास इसका संदर्भ(reference) है।
 इसलिए, उन सभी संदर्भों को स्थिर रखना होगा।
 अधिक नुकसान हो सकता है, लेकिन ये आम हैं।
 इसलिए, मैं सिर्फ उनकी चर्चा करना चुनता हूं।
 अब, हम ऐसा क्यों कर रहे हैं? इसलिए, मुझे फंक्शंस(functions) के लिए मापदंडों को पारित करने की एक पूरी तरह से नई अवधारणा पेश करना चाहिए।
 हम जानते हैं कि सी से कार्य करने के लिए पैरामीटर(parameter) कैसे पारित किया जाता है।
 इसे मूल्य द्वारा कॉल कहा जाता है।
 बस एक त्वरित पुनरावृत्ति के लिए, परिभाषित फ़ंक्शन(function) के औपचारिक पैरामीटर(parameter) हैं।
 जब यह कहा जाता है, मेरे पास वास्तविक पैरामीटर(parameter) हैं।
 वे स्थिति के क्रम में और कॉल के समय, प्रत्येक वास्तविक पैरामीटर्स के मूल्य को औपचारिक पैरामीटर(parameter) में कॉपी किया जाता है और फिर फ़ंक्शन(function) को कहा जाता है।
 इसलिए, जब कॉल किया जाता है, तो फ़ंक्शन(function) कॉल में होता है।
 वास्तविक पैरामीटर(parameter) कुछ मेमोरी(memory) में रहते हैं और इसी तरह के औपचारिक पैरामीटर(parameter) अलग अलग मेमोरी(memory) में रहते हैं।
 इसके विपरीत, हम वह कर सकते हैं जिसे संदर्भ(reference) द्वारा कॉल के रूप में जाना जाता है।
 इसलिए, मैं चाहूंगा कि आप इस विशेष लाइन पर ध्यान केंद्रित करें।
 हम कोशिश कर रहे हैं, हमने एक फ़ंक्शन(function) हेडर दिया है।
 परम परीक्षण के तहत कार्य एक प्रोटोटाइप है।
 इस पहले पैरामीटर(parameter) को देखें, जहां हम उस पैरामीटर(parameter) नाम को लिखते हैं जो उपसर्ग के साथ & लिखा है, जो संदर्भ(reference) के लिए अंकन है।
 ऐसे पैरामीटर(parameter) को संदर्भ(reference) पैरामीटर(parameter) कहा जाता है।
 मेरे पास उस फ़ंक्शन(function) में एक और पैरामीटर(parameter) सी भी है, जो कि विशिष्ट मूल्य पैरामीटर(parameter) है और हम मूल्य नियमों द्वारा कॉल का पालन करेंगे।
 अब, हम उपयोग के इस भाग को देखते हैं।
 तो, उस का उपयोग करें और हम एक चर(variable) के लिए चुनते हैं, और फ़ंक्शन(function) को कॉल करते हैं।
 यही है, वास्तविक पैरामीटर(parameter) के रूप में हम दोनों औपचारिक मापदंडों के स्थान पर एक पास करते हैं।
 फिर, यह फ़ंक्शन(function) की परिभाषा है; जहां दो पैरामीटर(parameter) दिए गए हैं, हम सिर्फ उनका मूल्य प्रिंट(print) करते हैं और हम सिर्फ उनके पते(address) प्रिंट(print) करते हैं।
 अब, आउटपुट(output) में देखते हैं।
 इसलिए यदि हम ऐसा करते हैं, तो पहला आउटपुट(output) फ़ंक्शन(function) कॉल से पहले इस स्लाइड से आएगा, जो यह आउटपुट(output) है, जो मुझे बताता है कि इस स्थान पर है।
 और, यह पता है।
 दूसरा आउटपुट(output) इस cout से आएगा, जो b को प्रिंट(print) करता है और b का एड्रेस देता है।
 देखिए कुछ बेहद दिलचस्प।
 B का पता उसी के पते(address) के समान है, जिसे हम मूल्य तंत्र द्वारा कॉल में उम्मीद नहीं करते हैं।
 और, सिर्फ यह दिखाने के लिए कि मूल्य के आधार पर क्या कॉल किया गया है, आप तीसरे आउटपुट(output) लाइन कॉट और पैरामीटर(parameter) सी के संबंधित आउटपुट(output) को देखेंगे।
 और, आप पाते हैं कि भले ही c का भी मान एक ही हो, जो कि होना चाहिए, c का पता अलग है।
 तो, यह स्पष्ट रूप से दिखाता है कि दो मापदंडों के बीच बी और सी, सी मूल नियम द्वारा मूल कॉल का पालन कर रहे हैं जिसके द्वारा सिर्फ एक मूल्य है जिसे c की प्रतिलिपि बनाया गया है।
 a और c दो अलग-अलग मेमोरी(memory) लोकेशन में मौजूद हैं, जबकि, b मूल रूप से a का एक अलग नाम बन गया है।
 यह a के लिए एक उपनाम(alias) बन गया है।
 ये लक्षण जैसा कि हमने अभी उर्फ के लक्षणों पर देखा है कि जब मेरे पास दो चर(variable) अलग-अलग नाम हैं, लेकिन वे एक ही मेमोरी(memory) स्थान का आनंद लेते हैं और इसलिए एक ही मूल्य है।
 तो, यह एक संदर्भ(reference) चर(variable) है।
 इसलिए जब हम मापदंडों का उपयोग करते हैं, मापदंडों में संदर्भ(reference) चर(variable), हम उन्हें संदर्भ(reference) तंत्र द्वारा कॉल के रूप में कहते हैं।
 इसलिए, वास्तविक पैरामीटर(parameter) के संदर्भ(reference) में कॉल और औपचारिक पैरामीटर(parameter) में कॉलर और कैली में अलग-अलग नाम होंगे, लेकिन उनके पास एक ही मेमोरी(memory) स्थान होगा।
 तो, यह नई सुविधा है जो C ++ हमें करने की अनुमति देती है।
 यहां, मैंने जो कुछ भी कहा है वह स्लाइड के निचले भाग में लिखा गया है।
 आप बस इतना पढ़ सकते हैं।
 अब, हम थोड़ी देर के लिए अध्यक्षता करेंगे।
 हमने केवल सीखा है, संदर्भ(reference) तंत्र द्वारा कॉल क्या है।
 लेकिन, हम अभी भी आश्चर्य करेंगे कि हम ऐसा क्यों करना चाह रहे हैं।
 इसलिए, यह समझने के लिए कि हम ऐसा करने की कोशिश क्यों कर रहे हैं, मैं सी से एक उदाहरण लेता हूं।
 और, यह एक उदाहरण है, जो आप में से प्रत्येक ने, जिन्होंने सी के बारे में बहुत कम किया है, उन्हें पता होगा कि मैं एक स्वैप(swap) फ़ंक्शन(function) लिखने की कोशिश कर रहा हूं।
 यह होगा, जो दो चर(variable), और बी लेगा और उन्हें स्वैप(swap) करने का प्रयास करेगा।
 इसलिए, यह वही है जिस पर हम ध्यान केंद्रित कर रहे हैं।
 यह एक हस्ताक्षर है।
 अगर मैं यह फ़ंक्शन(function) लिखता हूं, अगर मैं लिखता हूंयह कोड मैं यहाँ स्वैप(swap) कह रहा हूँ और यह पता लगाने के लिए कि a और b का मूल्य क्या है।
 तो, यह एक पहला प्रिंट(print) है जो इस विशेष प्रिंट(print) से आता है; जो दिखाता है कि ए और बी स्वैप(swap) में 10 और 15 के मान हैं, क्योंकि वे आरंभीकृत हैं।
 फिर, मैं स्वैप(swap) करने जाता हूं।
 तो, सी और डी 10 और 15 हो जाता है, स्वैप(swap) का कोड उन्हें स्वैप(swap) करता है और वापस, मैं फिर से प्रिंट(print) करता हूं।
 लेकिन, दुर्भाग्य से मूल्यों, वास्तविक मापदंडों की अदला-बदली नहीं की गई है।
 इसलिए, स्वैप(swap) ने काम नहीं किया और यह उम्मीद की जानी चाहिए।
 क्योंकि तंत्र क्या है? मूल्य द्वारा तंत्र कॉल है; जिसका अर्थ है कि जब मैंने फ़ंक्शन(function) स्वैप(swap) को कॉल किया है, तो फ़ंक्शन(function) ने इसे कॉपी करने के लिए इसे c के लिए ले लिया है, b की वैल्यू को इसे d पर कॉपी कर लिया है।
 और फिर, फ़ंक्शन(function) ने जो कुछ भी करना था, वह किया है।
 इसने सी और डी की अदला-बदली की थी।
 लेकिन, इन c और d में a और b से अलग स्थान हैं।
 तो, कुछ भी नहीं हुआ है, और बी।
 वे वास्तविक मापदंडों के रूप में अच्छी तरह से संरक्षित हैं।
 इसलिए, जब फ़ंक्शन(function) वापस आता है, और बी समान होते हैं।
 उन्हें स्वैप(swap) नहीं किया गया है।
 इसलिए, स्वैपिंग इस तरह से काम नहीं करती है।
 इसलिए, हमने C में सीखा है कि हम इस तरह स्वैप(swap) नहीं लिख सकते।
 तो, मुझे क्या करना है? मुझे आसपास कुछ छल करना है; कुछ तरकीबें।
 तो, हम क्या चाल चलते हैं? जिस ट्रिक को हम करने की कोशिश करते हैं, वह इस प्रकार स्वैप(swap) को परिभाषित करती है।
 मैंने इसका उल्लेख पते(address) के रूप में किया है; कॉल बाय एड्रेस बहुत औपचारिक रूप से स्वीकृत नाम नहीं है।
 इसे वास्तव में मूल्य कहा जाता है, लेकिन अंतर केवल इतना है कि यहां जो पैरामीटर(parameter) हम पास करते हैं वह एक पॉइंटेड प्रकार पैरामीटर(parameter) है।
 तो, हम कहते हैं कि दो पूर्णांकों की अदला-बदली करने के बजाय, अब हम पूर्णांक के लिए दो बिंदुओं को स्वैप(swap) करेंगे।
 इसलिए, यह कोड पॉइंटर्स के साथ भी लिखा जाता है, जहां और ये पॉइंटर्स हैं।
 जब भी मुझे पहले का उल्लेख करना होता है, तो मुझे इसे *x अभी और दूसरे को *y से करना होगा और हम ऐसा करेंगे।
 इसलिए, ये संकेत हैं, अगर मुझे उन्हें इस स्लाइड पर कॉल करना है, तो दो वास्तविक मापदंडों a, और b को a के पते(address) और b के पते(address) के रूप में पारित करना होगा।
 तो, हम दो पते(address) पास करते हैं।
 अब, क्या हो रहा है, अगर मैं एक्स को देखता हूं; एक के लिए एक सूचक(pointer) है।
 y, b का सूचक(pointer) है।
 अब, यह क्या कर रहा है? यह * x और * y के मान को स्वैप(swap) करने का प्रयास कर रहा है।
 यह x और y का मान नहीं बदल रहा है।
 यह इनकी अदला-बदली नहीं है।
 यह * x और * y के मानों की अदला-बदली कर रहा है।
 * X क्या है? * x वास्तव में ए है।
 यदि x a का पता है, तो * x वास्तव में है।
 तो, जब मैं स्वैप(swap) * x और इसी तरह * y, यह वास्तव में बी है।
 इसलिए, जब मैं * y के साथ * x स्वैप(swap) करता हूं, तो मैं वास्तव में b के साथ स्वैप(swap) कर रहा हूं।
 इसलिए, मैं जो कर रहा हूं, मूल रूप से कॉल बाय वैल्यू मुझे वास्तविक पैरामीटर(parameter) में बदलाव करने की अनुमति नहीं देगा, मैं उनके पते(address) बाहर भेज रहा हूं और दूरस्थ रूप से मैं स्वैप(swap) मापदंडों को वास्तविक मापदंडों को संदर्भित करने के लिए पते(address) का उपयोग करने की अनुमति दे रहा हूं, और फिर परिवर्तन करें।
 इसलिए, एक तरह से मैं मूल्य से कॉल के नियम को तोड़ रहा हूं क्योंकि इसके बिना मैं बदलाव वापस नहीं ला सकता।
 तो, यहाँ हमारे पास होगा; हम देखते है कि।
 चूँकि हम सीधे मानों को स्वैप(swap) नहीं कर पा रहे हैं, हम कॉल का उपयोग पते(address) के प्रकार के तंत्र से करते हैं, जहाँ हम पते(address) पास करते हैं और उन मानों को उन पते(address) तक पहुँचाते हैं।
 निश्चित रूप से, यह परिणाम प्राप्त करने, पाने के लिए एक पिछले दरवाजे का प्रकार है।
 और, हम ऐसा क्यों कर रहे हैं? मूल लक्षण क्या है जिसके लिए हमें यह करना होगा? स्वैप(swap) एक विशिष्ट उदाहरण हो सकता है।
 लक्षण यह है कि यदि हम मूल्य से कॉल करते हैं, तो वास्तविक पैरामीटर(parameter) को औपचारिक पैरामीटर(parameter) में कॉपी किया जाता है।
 इसलिए, आप औपचारिक पैरामीटर(parameter) के साथ फ़ंक्शन(function) में जो भी करते हैं, वे प्रभाव कभी भी वास्तविक पैरामीटर(parameter) पर वापस नहीं आएंगे।
 यह वही है जो हम चाहते थे।
 लेकिन, स्वैप(swap) में हमें वास्तविक पैरामीटर(parameter) पर वापस आने के लिए औपचारिक पैरामीटर(parameter) में बदलाव की आवश्यकता होती है।
 तभी, स्वैप(swap) हो सकता है।
 अगर मैं एक स्वैप(swap) कर रहा हूं, और बी, जब तक कि बदल नहीं सकता है और जब तक बी नहीं बदल सकता है, तब तक स्वैप(swap) नहीं होगा।
 तो सामान्य करने के लिए, मूल्य से कॉल हमें केवल इनपुट(input) प्रकार के मापदंडों की अनुमति देता है; क्या मान कॉलर फ़ंक्शन(function) से कॉल किए गए फ़ंक्शन(function) पर जा सकते हैं।
 लेकिन, मूल्य से कॉल मुझे आउटपुट(output) प्रकार के पैरामीटर(parameter) को करने की अनुमति नहीं देता है; अर्थात्, मैं फ़ंक्शन(function) में मान की गणना नहीं कर सकता और इसे पैरामीटर(parameter) पर वापस ला सकता हूं।
 इसलिए, जैसे कि फ़ंक्शन(function) केवल एक मान लौटाता है।
 इसलिए, अगर मुझे एक ऐसा फ़ंक्शन(function) चाहिए, जिसमें से मुझे एक से अधिक आउटपुट(output) चाहिए, तो मेरे पास कोई मैकेनिज्म नहीं है, सी।
 वैल्यू बाय स्ट्रेट मैकेनिज्म है।
 इसलिए, केवल अन्य तंत्र पतों का उपयोग करना है और इसे एक दौर में करना है।
 अब, हम देखते हैं।
 अब, हमने जिन दो कारकों पर बात की है, उन्हें संयोजित करने का प्रयास करें।
 एक, हमने संदर्भ(reference) की अवधारणा पेश की है, संदर्भ(reference) द्वारा कॉल करें और हमने एक फ़ंक्शन(function) से एक सी फ़ंक्शन(function) से कई आउटपुट(output) होने की कठिनाई के बारे में बात की है।
 तो, आइए हम विशेष रूप से स्वैप(swap) उदाहरण में फिर से देखें।
 अब, आइए।
 बाईं ओर, हमारे पास उदाहरण के लिए कॉल है।
 जो उदाहरण हमने देखा वह वास्तव में गलत है क्योंकि यह बदल नहीं सकता क्योंकि इसे बदलना नहीं चाहिए।
 यह मूल्य प्रोटोटाइप द्वारा कॉल है।
 अब, यहाँ C ++ में हमारे द्वारा किए गए सभी परिवर्तन केवल मूल्य के आधार पर कॉल करने के बजाय हैं।
 अब हम कह रहे हैं कि हमारे पास दो पैरामीटर(parameter) हैं, जिन्हें संदर्भ(reference) द्वारा कहा जाता है।
 यह पैरामीटर(parameter) सामान्य पैरामीटर(parameter) नहीं हैं।
 वे संदर्भ(reference) पैरामीटर(parameter) हैं।
 और, अब आप संदर्भ(reference) पैरामीटर(parameter) के साथ पूरी बात लिखते हैं।
 इसके बाकी, जो आप C में देखते हैं और C ++ में जो आप देखते हैं, उसके बीच का कोड समान है।
 ये सिर्फ दो जगह हैं जहां बदलाव किए गए हैं।
 प्रभाव क्या है? यदि यह संदर्भ(reference) से एक कॉल है, तो जब यह विशेष कॉल होता है, तो वास्तविक पैरामीटर(parameter) ए और औपचारिक पैरामीटर(parameter) एक्स यहां, वे हैं, वे उसी स्थान का आनंद लेते हैं; x, a का दूसरा नाम है, y, b का दूसरा नाम है।
 इसलिए, अगर मैं x और y को इंटरचेंज करता हूं तो यह ए, और बी को इंटरचेंज करने के समान है।
 तो, मैं अपने कोड में पूरा प्रभाव प्राप्त कर सकता हूं।
 तो, ऐसा करने से मुझे क्या लाभ होगा? कई चीजे; एक मैं पीछे के दरवाजे पर ले जाने की जरूरत नहीं है।
 अगर मैं एक पैरामीटर(parameter) इनपुट(input) चाहता हूं, तो मैं मूल्य से कॉल करता हूं; अगर मैं चाहता हूं कि पैरामीटर(parameter) आउटपुट(output) के रूप में अच्छी तरह से हो, तो मैं संदर्भ(reference) द्वारा कॉल करूंगा क्योंकि तब फ़ंक्शन(function) के भीतर उस औपचारिक पैरामीटर(parameter) में किए गए परिवर्तन वास्तविक मापदंडों में भी उपलब्ध होंगे; क्योंकि वास्तविक पैरामीटर(parameter) और संबंधित औपचारिक पैरामीटर(parameter) समान पते(address) का आनंद लेते हैं।
 तो, यह संदर्भ(reference) का उपयोग करने और C ++ में संदर्भ(reference) तंत्र द्वारा कॉल करने का लाभ है।
 यह निश्चित रूप से कोड को बहुत क्लीनर बनाता है।
 यह प्रोग्राम लिखना अधिक आसान और विश्वसनीय बनाता है।
 और, जैसा कि हम बाद में देखेंगे, यह अक्सर बहुत सारे प्रयासों को बचाता है क्योंकि मूल्य से कॉल में आपको उस मूल्य की एक प्रति बनानी होगी।
 अब, जब तक आपका मूल्य पूर्णांक है, तब तक एक प्रति बनाना महंगा नहीं हो सकता है।
 लेकिन, सोचिए, यदि आप हैं, यदि आप जिस पैरामीटर(parameter) से गुजर रहे हैं, संभवत: एक ऐसी संरचना है, जिसमें 10 किलो बाइट हो सकती है, जिसमें 200 अलग-अलग सदस्य, 200 अलग-अलग घटक होते हैं, तो इसकी नकल करना आपके लिए बहुत महंगा हो सकता है।
 तो, आप उस लागत को उठाना नहीं चाहेंगे।
 आप केवल संदर्भ(reference) का उपयोग कर सकते हैं।
 संदर्भ(reference) पैरामीटर(parameter) का उपयोग करने का एक साइड इफेक्ट है।
 अब, कहा जाता है कि, यदि हम एक संदर्भ(reference) पैरामीटर(parameter) करते हैं, अर्थात् यदि हम संदर्भ(reference) द्वारा कॉल का उपयोग करते हैं, तो पैरामीटर(parameter) वास्तव में इनपुट(input) और आउटपुट(output) पैरामीटर(parameter) है।
 यह इनपुट(input) है क्योंकि, जब मैं वास्तविक पैरामीटर(parameter) के पास जो कुछ भी मूल्य कह रहा हूं, तो औपचारिक पैरामीटर(parameter) का भी समान मूल्य होगा।
 तो, यह इनपुट(input) के उद्देश्य को पूरा करता है।
 इसलिए, वास्तव में मुझे कॉल करने की आवश्यकता नहीं है।
 मैं केवल संदर्भ(reference) द्वारा कॉल का उपयोग कर सकता हूं।
 लेकिन, अगर मैं संदर्भ(reference) से कॉल करता हूं, तो संभावना यह है कि औपचारिक पैरामीटर(parameter) में किए गए किसी भी परिवर्तन को वास्तविक पैरामीटर(parameter) में भी प्रतिबिंबित किया जाएगा।
 इसलिए, औपचारिक पैरामीटर(parameter) में जानबूझकर किया गया कोई भी अनौपचारिक परिवर्तन या औपचारिक पैरामीटर(parameter) में किया गया परिवर्तन, मेरे वास्तविक पैरामीटर(parameter) को खराब कर देगा।
 तो, क्या हम कुछ ऐसा कर सकते हैं जिससे मैं संदर्भ(reference) द्वारा कॉल का उपयोग कर सकता हूं, लेकिन बस इसे एक इनपुट(input) पैरामीटर(parameter) बनाएं।
 तो, ऐसा करने के लिए, आप const का उपयोग करते हैं।
 तो, यहाँ क्या है? बस यहाँ कोड देखें।
 इस फ़ंक्शन(function) पर विशेष रूप से ध्यान केंद्रित करें, जो कि प्रकार का एक औपचारिक पैरामीटर(parameter) x ले रहा है int।
 लेकिन, हमने क्या किया है? इससे पहले हम कह चुके हैं कि यह कांस्ट है।
 तो उसका क्या मतलब हुआ? क्योंकि यह संदर्भ(reference) द्वारा एक कॉल है क्योंकि यह एक संदर्भ(reference) पैरामीटर(parameter) है, इसलिए जब मैं इसे इस बिंदु पर कॉल करता हूं ए; ए और एक्स एक ही पते(address) का संदर्भ(reference) देते हैं।
 लेकिन, मैं कह रहा हूं कि संदर्भ(reference) x स्थिर है; जिसका अर्थ है कि x का कोई भी परिवर्तन संभव नहीं है।
 यह एक ऐसी स्थिति है जो पॉइंटर(pointer) की कमी और पॉइंटेड डेटा की संक्षिप्तता के मामले में चर्चा करने के समान है।
 हमें यकीन है कि डेटा अपने आप में स्थिर नहीं हो सकता है, लेकिन अगर मैं उस डेटा को इंगित किया गया एक स्थिर पकड़ रहा हूं, तो निश्चित रूप से वह सूचक(pointer) मुझे डेटा बदलने की अनुमति नहीं देगा।
 इसलिए, इसी तरह यहां मेरे पास एक निरंतर संदर्भ(reference) है या बल्कि मेरे पास डेटा की संक्षिप्तता का संदर्भ(reference) है।
 इसलिए, x मुझे बदलने की अनुमति नहीं देगा।
 इसलिए, यदि फ़ंक्शन(function) के भीतर, मैं ++ x जैसा कुछ लिखने की कोशिश करता हूं।
 यह कोड संकलित नहीं करेगा क्योंकि ++ x होने के कारण मैं x का मान बदलने का प्रयास कर रहा हूं।
 लेकिन, x एक स्थिर संदर्भ(reference) है।
 x एक स्थिर मान है।
 तो, जो भी इसके साथ आरंभ हुआ।
 इसके साथ क्या आरंभ हुआ? यह एक साथ आरंभ हुआ।
 जब कॉल किया गया था जिसे बदला नहीं जा सकता है।
 तो, अब क्या होता है? कॉल के समय वसीयत का मान x के मान के रूप में उपलब्ध होगा।
 वही पता है।
 लेकिन x, आप फ़ंक्शन(function) के भीतर नहीं बदल सकते।
 इसलिए, कुल्हाड़ी में कोई भी बदलाव वास्तविक पैरामीटर(parameter) को प्रभावित नहीं कर सकता है।
 इसलिए, प्रभाव वापस नहीं आ सकता है।
 तो, अब, पैरामीटर(parameter) विशुद्ध रूप से एक इनपुट(input) पैरामीटर(parameter) बन जाता है।
 इसलिए, एक संदर्भ(reference) का उपयोग करके हम या तो इनपुट(input) आउटपुट(output) पैरामीटर(parameter) बना सकते हैं या हम इनपुट(input) को केवल पैरामीटर(parameter) बना सकते हैं, यदि हम एक निरंतर संदर्भ(reference) पैरामीटर(parameter) बनाते हैं।
 इसलिए, मूल्य द्वारा कॉल का उपयोग करने के बजाय, बड़ी संख्या में मामलों में हम सिर्फ निरंतर संदर्भ(reference) पैरामीटर(parameter) का उपयोग करने का प्रयास करेंगे; क्योंकि आपको कॉपी करने की आवश्यकता नहीं होगी।
 और, हम अभी भी सुरक्षित रहेंगे कि हमारा वास्तविक पैरामीटर(parameter) प्रभावित नहीं होगा।
 इसलिए, दाहिने हाथ की तरफ हम सिर्फ यह दर्शाते हैं कि, इसे करने का एक उचित तरीका क्या है, जहां x एक निरंतर संदर्भ(reference) है और आप इसे करने की कोशिश नहीं करते हैं।
 इधर, हम एक्स को बढ़ाने की कोशिश कर रहे थे और फिर उसे वापस कर रहे थे।
 यहाँ, हम ऐसा नहीं करते हैं।
 हम इसके साथ एक जोड़ने के साथ x की गणना करते हैं और फिर उसे वापस करते हैं।
 दाहिने हाथ की ओर कोड संकलित और अच्छी तरह से चलेगा।
 कोई उल्लंघन नहीं है।
 बाईं ओर के कोड में संकलन त्रुटि होगी और हम उस पर आगे नहीं बढ़ पाएंगे।
 इस बिंदु पर, हम बंद कर देंगे और हम अगले भाग में जारी रखेंगे।