C ++ और Java में कन्वेंशन को कॉल करने में कुछ अंतर हैं। C ++ में तकनीकी रूप से केवल दो सम्मेलन बोलते हैं: पास-बाय-वैल्यू और पास-बाय-रेफरेंस, कुछ साहित्य के साथ जिसमें तीसरा पास-बाय-पॉइंटर कन्वेंशन (जो वास्तव में एक पॉइंटर प्रकार का पास-बाय-वैल्यू है)। इसके शीर्ष पर, आप शब्दार्थ को बढ़ाते हुए, तर्क के प्रकार में const-ness जोड़ सकते हैं।
संदर्भ से गुजारें
संदर्भ से गुजरने का अर्थ है कि फ़ंक्शन वैचारिक रूप से आपकी ऑब्जेक्ट आवृत्ति प्राप्त करेगा और इसकी प्रतिलिपि नहीं। संदर्भ वैचारिक रूप से उस वस्तु के लिए एक उपनाम है जिसका उपयोग कॉलिंग संदर्भ में किया गया था, और यह शून्य नहीं हो सकता है। फ़ंक्शन के अंदर किए गए सभी ऑपरेशन फ़ंक्शन के बाहर ऑब्जेक्ट पर लागू होते हैं। यह कन्वेंशन जावा या सी में उपलब्ध नहीं है।
मान से गुजरें (और पास-दर-सूचक)
कंपाइलर कॉलिंग संदर्भ में ऑब्जेक्ट की एक प्रति उत्पन्न करेगा और फ़ंक्शन के अंदर उस कॉपी का उपयोग करेगा। फ़ंक्शन के अंदर किए गए सभी ऑपरेशन कॉपी करने के लिए किए जाते हैं, बाहरी तत्व से नहीं। यह जावा में आदिम प्रकार के लिए सम्मेलन है।
इसका एक विशेष संस्करण एक फ़ंक्शन में एक पॉइंटर (ऑब्जेक्ट का पता-) गुजर रहा है। फ़ंक्शन पॉइंटर को प्राप्त करता है, और पॉइंटर पर लगाए गए किसी भी और सभी ऑपरेशंस को स्वयं कॉपी (पॉइंटर) पर लागू किया जाता है, दूसरी तरफ, डीरफेर किए गए पॉइंटर पर लागू किए गए ऑपरेशन उस मेमोरी लोकेशन पर ऑब्जेक्ट इंस्टेंस पर लागू होंगे, इसलिए फ़ंक्शन दुष्प्रभाव हो सकते हैं। ऑब्जेक्ट के लिए एक पॉइंटर के पास-बाय-वैल्यू का उपयोग करने के प्रभाव से आंतरिक फ़ंक्शन बाहरी मानों को संशोधित करने की अनुमति देगा, जैसा कि पास-बाय-संदर्भ के साथ होगा और वैकल्पिक मानों (एक शून्य पॉइंटर पास) के लिए भी अनुमति देगा।
यह वह कन्वेंशन है जिसका उपयोग C में तब किया जाता है जब किसी फ़ंक्शन को बाहरी चर को संशोधित करने की आवश्यकता होती है, और संदर्भ प्रकारों के साथ जावा में उपयोग किए जाने वाले कन्वेंशन: संदर्भ की प्रतिलिपि बनाई जाती है, लेकिन संदर्भित ऑब्जेक्ट समान है: संदर्भ / पॉइंटर के परिवर्तन बाहर दिखाई नहीं दे रहे हैं फ़ंक्शन, लेकिन इंगित की गई मेमोरी में परिवर्तन होते हैं।
समीकरण में कास्ट जोड़ना
C ++ में आप विभिन्न स्तरों पर चर, बिंदुओं और संदर्भों को परिभाषित करते समय वस्तुओं को निरंतर-नेस असाइन कर सकते हैं। आप एक चर को स्थिर होने की घोषणा कर सकते हैं, आप एक निरंतर उदाहरण के लिए एक संदर्भ की घोषणा कर सकते हैं, और आप सभी बिंदुओं को निरंतर वस्तुओं, निरंतर बिंदुओं को उत्परिवर्तित वस्तुओं और निरंतर तत्वों के लिए निरंतर संकेत को परिभाषित कर सकते हैं। जावा में इसके विपरीत आप केवल निरंतर-नेस (अंतिम कीवर्ड) के एक स्तर को परिभाषित कर सकते हैं: चर (उदाहरण के लिए आदिम प्रकार, संदर्भ प्रकारों के लिए संदर्भ), लेकिन आप एक अपरिवर्तनीय तत्व के संदर्भ को परिभाषित नहीं कर सकते (जब तक कि वर्ग स्वयं नहीं है) अपरिवर्तनीय)।
यह C ++ कॉलिंग सम्मेलनों में बड़े पैमाने पर उपयोग किया जाता है। जब ऑब्जेक्ट छोटे होते हैं तो आप ऑब्जेक्ट को मूल्य से पास कर सकते हैं। कंपाइलर एक कॉपी जनरेट करेगा, लेकिन वह कॉपी एक महंगा ऑपरेशन नहीं है। किसी अन्य प्रकार के लिए, यदि फ़ंक्शन ऑब्जेक्ट नहीं बदलेगा, तो आप टाइप के एक निरंतर उदाहरण (आमतौर पर स्थिर संदर्भ) कहा जाता है। यह ऑब्जेक्ट को कॉपी नहीं करेगा, लेकिन इसे फ़ंक्शन में पास करेगा। लेकिन एक ही समय में संकलक गारंटी देगा कि फ़ंक्शन के अंदर ऑब्जेक्ट नहीं बदला गया है।
अंगूठे का नियम
यह पालन करने के लिए कुछ बुनियादी नियम हैं:
- आदिम प्रकारों के लिए पास-दर-मूल्य को प्राथमिकता दें
- अन्य प्रकारों के लिए स्थिरांक के साथ पास-दर-संदर्भ को प्राथमिकता दें
- यदि फ़ंक्शन को तर्क-दर-संदर्भ को संशोधित करने की आवश्यकता है
- यदि तर्क वैकल्पिक है, तो पास-दर-पॉइंटर का उपयोग करें (यदि वैकल्पिक मान को संशोधित नहीं किया जाना चाहिए तो स्थिर करने के लिए)
इन नियमों से अन्य छोटे विचलन हैं, जिनमें से पहला किसी वस्तु के स्वामित्व को संभाल रहा है। जब किसी वस्तु को गतिशील रूप से नए के साथ आवंटित किया जाता है, तो उसे डिलीट (या [] संस्करणों से हटा दिया जाना चाहिए)। ऑब्जेक्ट के विनाश के लिए जिम्मेदार ऑब्जेक्ट या फ़ंक्शन को संसाधन का मालिक माना जाता है। जब कोड के एक टुकड़े में एक गतिशील रूप से आवंटित वस्तु बनाई जाती है, लेकिन स्वामित्व को एक अलग तत्व में स्थानांतरित किया जाता है, जो आमतौर पर पास-बाय-पॉइंटर शब्दार्थ के साथ, या यदि संभव हो तो स्मार्ट पॉइंटर्स के साथ किया जाता है।
पक्षीय लेख
C ++ और Java सन्दर्भों के बीच के अंतर को महत्व देना महत्वपूर्ण है। C ++ सन्दर्भ में, वस्तुगत रूप से वस्तु का उदाहरण है, न कि इसका उपयोग करने वाला। सबसे सरल उदाहरण एक स्वैप फ़ंक्शन लागू कर रहा है:
// C++
class Type; // defined somewhere before, with the appropriate operations
void swap( Type & a, Type & b ) {
Type tmp = a;
a = b;
b = tmp;
}
int main() {
Type a, b;
Type old_a = a, old_b = b;
swap( a, b );
assert( a == old_b );
assert( b == old_a );
}
ऊपर दिया गया स्वैप फ़ंक्शन संदर्भों के उपयोग के माध्यम से अपने दोनों तर्कों को बदल देता है। जावा में निकटतम कोड:
public class C {
// ...
public static void swap( C a, C b ) {
C tmp = a;
a = b;
b = tmp;
}
public static void main( String args[] ) {
C a = new C();
C b = new C();
C old_a = a;
C old_b = b;
swap( a, b );
// a and b remain unchanged a==old_a, and b==old_b
}
}
कोड का जावा संस्करण आंतरिक रूप से संदर्भों की प्रतियों को संशोधित करेगा, लेकिन वास्तविक वस्तुओं को बाहरी रूप से संशोधित नहीं करेगा। जावा संदर्भ सी अंक सूचक के बिना सी पॉइंटर्स हैं जो कार्यों में मूल्य से पारित हो जाते हैं।