तुलना चार्ट:
| तुलना के लिए आधार | Call_By_Value | संदर्भ से कॉल करें |
|---|---|---|
| बुनियादी | चर की एक प्रति पारित की जाती है। | एक चर ही पारित किया है। |
| प्रभाव | चर की एक प्रति में परिवर्तन फ़ंक्शन के पक्ष के बाहर चर के मूल मूल्य को संशोधित नहीं करता है। | चर में परिवर्तन समारोह के बाहर चर के मूल्य को भी प्रभावित करता है। |
| कॉलिंग पैरामीटर्स | function_name (variable_name1, variable_name2, ।);) | function_name ((variable_name1, और variable_name2, ।)); // वस्तु के मामले में object.func_name (ऑब्जेक्ट); |
| पैरामीटर्स प्राप्त करना | function_name टाइप करें (variable_name1 टाइप करें, variable_name2 टाइप करें।)।) {। । } | function_name टाइप करें (टाइप करें * variable_name1, टाइप करें * variable_name2, ।)।) {। । } // वस्तु के मामले में function_name टाइप करें (class_type object_name) {। । } |
| डिफ़ॉल्ट कॉलिंग | आदिम प्रकार "कॉल बाय वैल्यू" का उपयोग करके पारित किए जाते हैं। | ऑब्जेक्ट को "संदर्भ द्वारा कॉल" का उपयोग करते हुए स्पष्ट रूप से पारित किया जाता है। |
कॉल बाय वैल्यू की परिभाषा
यदि आप एक समारोह / विधि के लिए एक आदिम डेटा प्रकार (पूर्णांक, वर्ण और स्ट्रिंग) पास करते हैं, तो केवल "मान" फ़ंक्शन कोड के लिए पारित किया जाता है। फ़ंक्शन फ़ंक्शन कोड के 'औपचारिक पैरामीटर' के तर्क के मूल्य की प्रतिलिपि बनाता है। यदि किसी फ़ंक्शन कोड में औपचारिक पैरामीटर के लिए कोई संशोधन है, तो यह उस फ़ंक्शन के मूल मान को संशोधित नहीं करेगा जो इस फ़ंक्शन को कॉल करने के लिए उपयोग किया जाता है।
सरल शब्दों में, यदि किसी फ़ंक्शन / विधि को 'कॉल बाय वैल्यू' दृष्टिकोण कहा जाता है; तब चर की एक प्रति फ़ंक्शन कोड को दी जाती है। यदि कोई फ़ंक्शन कोड चर की कॉपी में मूल्य में कोई बदलाव करता है, तो यह चर के मूल मूल्य को नहीं बदलता है।
आइए इसे संक्षेप में समझने के लिए एक उदाहरण देखते हैं।
// उदाहरण जावा श्रेणी की जाँच में {शून्य परिवर्तन (int i, int j) {i = i * i; j = j / 2; system.out.println ("फ़ंक्शन के अंदर पैरामीटर का मान"); system.out.println ("'i' का मान जो तर्क 'a'" + i) के मूल्य को स्वीकार करता है; system.out.println ("'j' का मान जो तर्क 'b'" + j) के मान को स्वीकार करता है; }} वर्ग call_by _value {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग args []) {int a = 12, b = 20; check C = नया चेक (); system.out.println ("फंक्शन कॉल से पहले 'a' और 'b' का मान" + a + "" + b); C.change (ए, बी); // मूल्य से कॉल करें। system.out.println ("फंक्शन कॉल" + a + "" + b) के बाद 'a' और 'b' का मान; }} // फंक्शन से पहले 'a' और 'b' का आउटपुट वैल्यू 'i' के फंक्शन वैल्यू के अंदर पैरामीटर के 12 20 वैल्यू को कॉल करता है, जो 'a' के 'value' को 'j' का 144 मान मानता है, जो 'value' को स्वीकार करता है। फ़ंक्शन 'बी' '10' का 'ए' और 'बी' फ़ंक्शन 20 20 कॉल के बाद संदर्भ द्वारा कॉल की परिभाषा
फ़ंक्शन विधि द्वारा कॉल को संदर्भ विधि के संदर्भ / पते से पास किया जाता है। चूंकि किसी तर्क का पता फ़ंक्शन कोड को दिया जाता है, इसलिए उस पते को स्वीकार करने वाला औपचारिक पैरामीटर एक 'पॉइंटर' चर होगा। अब, जैसा कि फ़ंक्शन कोड ने एक तर्क का पता प्राप्त किया है, एक तर्क के मूल्य में संशोधन भी एक तर्क के मूल मूल्य को संशोधित करेगा।
C ++ और Java में, ऑब्जेक्ट को फंक्शन / मेथड को पास करना बहुत आम है और ऑब्जेक्ट हमेशा इसके संदर्भ से गुजरता है। फ़ंक्शन / विधि के अंदर ऑब्जेक्ट में किए गए परिवर्तन उस फ़ंक्शन / विधि को लागू करने के लिए उपयोग की जाने वाली वस्तु को प्रभावित करते हैं।
निम्नलिखित टुकड़ा 'संदर्भ द्वारा कॉल' करने का सही तरीका दिखाता है।
// उदाहरण में C ++ वर्ग स्वैप {void स्वैप (int * x, int * y) {int अस्थायी; अस्थायी = * x; * एक्स = * y; * Y अस्थायी =; }} int main {int a = 10, b = 20; cout << "a, b का फंक्शन कॉल से पहले" << a << "" < अब एक तर्क के रूप में एक 'ऑब्जेक्ट' को पास करके 'कॉल फॉर रेफरेंस' पर चर्चा करते हैं, जो कि 'संदर्भ द्वारा कॉल' के दृष्टिकोण से निहित है।
कक्षा की जांच {int a, b; check (int x, int b) {// इस constrtuctor a = x के माध्यम से इनिशियलाइज़ किया गया; ख = y; } शून्य विनिमय (चेक आब) {ob.a = a * 2; ob.b = b / 2; }} वर्ग main_class {सार्वजनिक स्थैतिक शून्य मुख्य (string args []) {check C = new check (20, 40); // वस्तु आरंभीकरण। system.out.println ("फंक्शन कॉल से पहले" ob.a 'और' ob.b 'का मान "+ ob.a +" "+ ob.b); C.exchange (सी); // संदर्भ द्वारा कॉल करें। system.out.println ("फंक्शन कॉल से पहले" ob.a 'और' ob.b 'का मान "+ ob.a +" "+ ob.b); }} // 'call.a' और 'ob.b' के आउटपुट वैल्यू को फंक्शन कॉल से पहले 'ob.a' और 'ob.b' के 40 40 फंक्शन कॉल कॉल के बाद 40 20 मूल्य और कॉल बाय संदर्भ के बीच महत्वपूर्ण अंतर
- 'वैल्यू बाय कॉल' दृष्टिकोण का उपयोग करके तर्क पास करना केवल उस वेरिएबल की कॉपी को पास करता है, इसलिए उस वेरिएबल की कॉपी में मूल्य में किए गए परिवर्तन उस वेरिएबल के मूल मूल्य को प्रभावित नहीं करते हैं। 'कॉल बाय रेफरेंस' दृष्टिकोण में चर को एक तर्क के रूप में पारित किया जाता है, इसलिए इसमें परिवर्तन मूल चर के मूल्य को संशोधित करता है।
- यदि पारित किए गए तर्क आदिम डेटाैटिप्स हैं, तो वे केवल 'कॉल बाय वैल्यू' हैं, लेकिन यदि तर्कों या वस्तुओं के संदर्भ / पते पारित किए जाते हैं, तो एक फ़ंक्शन को 'कॉल बाय संदर्भ' विधि कहा जाता है।
- 'कॉल बाई वैल्यू एप्रोच' में दी गई दलीलें केवल चर का नाम हैं, जबकि 'कॉल बाय रेफरेंस' दृष्टिकोण के पास दी गई दलीलें हैं, चर नाम 'और' चिन्ह, या एक वस्तु जो कि सिर्फ उसके नाम से दी गई है।
- 'कॉल बाय वैल्यू' दृष्टिकोण में तर्क के मापदंडों को प्राप्त करने के लिए इसके डेटा प्रकार के साथ चर नाम हैं। 'कॉल बाय रेफरेंस' दृष्टिकोण में प्राप्त पैरामीटर हमेशा डेटा प्रकार के साथ-साथ एक सूचक चर होता है और वस्तु के मामले में यह अपने वर्ग प्रकार के साथ एक वस्तु का नाम है।
निष्कर्ष:
C ++ और Java जो पास है उसके आधार पर दोनों दृष्टिकोणों का उपयोग करते हैं। यदि आप केवल वैरिएबल यूज़'कॉल का वैल्यू एप्रोच पास करना चाहते हैं और यदि आप वैरिएबल के मूल मूल्य में परिवर्तन देखना चाहते हैं तो 'कॉल बाय रेफरेंस' एप्रोच का उपयोग करें।
