नियम

Question

संभव डुप्लिकेट:
How to pass objects to functions in C++?
Why pass by const reference instead of by value?

C++ में वहाँ नियम या जब ठीक एक चाहिए के मार्गदर्शन की तरह है या कम से कम चुनते चाहिए मूल्य से संदर्भों से पास का उपयोग करने के लिए?

और यदि किसी ऑब्जेक्ट के साथ ऑब्जेक्ट के आकार के बारे में पता है (थोड़ा ईमानदारी से) यह निर्णय लेना मुश्किल हो सकता है।

Answer 1

जब भी आप फ़ंक्शन के बाहर दिखाई देने के लिए तर्कों में परिवर्तन चाहते हैं तो आपको संदर्भ से गुजरना चाहिए। यह गैर-const संदर्भ द्वारा पास किया गया है और अधिकतर दक्षता के बजाय तर्क द्वारा प्रेरित है।

जब आप किसी रजिस्टर के मुकाबले बड़े आकार के डेटा प्रकार से निपट रहे हैं तो आपको (ज्यादातर const) संदर्भ पारित करना चाहिए। चूंकि संदर्भ अधिकतर const है, इसलिए आप इसमें कोई बदलाव नहीं कर सकते हैं, इसलिए यह दक्षता से प्रेरित है।

Answer 2

1. यदि आप ऑब्जेक्ट की कॉपी कन्स्ट्रक्टर का आह्वान नहीं करना चाहते हैं (उदाहरण के लिए, यदि ऐसा करना ऑब्जेक्ट आकार के कारण विस्तृत है)।
2. आप वास्तव में संदर्भ, और न केवल मूल्य की जरूरत है (swap(a,b), उदाहरण के लिए - के बाद से आप वास्तव में आदेश स्वैप करने के लिए मूल संदर्भ की जरूरत है।)

Answer 3

आम तौर पर, मैं में संदर्भ द्वारा पास का उपयोग निम्न स्थितियों:

1) objetc एक सूचक से भी बड़ा आकार है: इस मामले में, अगर मैं objetc संशोधित नहीं चाहते हैं, एक स्थिरांक संदर्भ का उपयोग करें:

Reference object; 

foo(object); 

foo के साथ के रूप में घोषित:

void foo(const Reference & object); 

2) कोड के लिए स्पष्ट है, इस तरह thigs से बचने की कोशिश: एक struct का उपयोग कर

int f1 = xxx; 
int f2 = yyy; 
int f3 = zzz; 
.... 

foo(f1, f2, ............) 

:

struct X 
{ 
    int f1; 
    int f2; 
    int f3; 
    .... 
}; 

X x; 
x.f1 = xxx; 
..... 

foo(X); 

foo के साथ के रूप में परिभाषित:

foo(const X & x); 

3) speedup pourposes के लिए: याद रखें कि कॉलिंग कार्यों को बराबर रखना चाहिए स्टैक पर मीटर) 4) आपको फ़ंक्शन के अंदर पैरामीटर को संशोधित करने की आवश्यकता है।

Reference object; 

foo(object); 

foo साथ

घोषित:

void foo(Reference & object); 

Answer 4

pass-by-value को pass-by-reference-to-const पसंद करते हैं। मूल्य से गुजरना एक महंगी ऑपरेशन है क्योंकि ऑब्जेक्ट की प्रतियां प्रतिलिपि बनाने वालों द्वारा उत्पादित की जाती हैं।साथ ही, यदि आपके पास कक्षा में कुछ गैर-आदिम डेटा सदस्य हैं (उदाहरण: std::string), हर बार कक्षा का एक नया ऑब्जेक्ट बनाया जाता है, तो std::string ऑब्जेक्ट भी बनाए जाएंगे।

संदर्भ द्वारा पास करने से slicing problem से बचा जाता है। यदि आप बेस क्लास ऑब्जेक्ट की अपेक्षा रखने वाले फ़ंक्शन के लिए व्युत्पन्न क्लास ऑब्जेक्ट को पास करते हैं, तो व्युत्पन्न कक्षा की व्युत्पन्न विशेषताओं को काट दिया जाएगा और फ़ंक्शन के अंदर ऑब्जेक्ट बेस क्लास ऑब्जेक्ट के रूप में व्यवहार करेगा। यदि आप संदर्भ से गुजरते हैं, तो स्लाइसिंग से बचा जा सकता है।

फिर भी, ऐसे कुछ मामले हैं जहां आप संदर्भ से पास नहीं कर सकते हैं। यदि आपके फ़ंक्शन तर्क या वापसी मान के पास शून्य मान होने की आवश्यकता है, तो आप संदर्भों का उपयोग नहीं कर सकते हैं।