गूगल के संकेत दिए गए

Question

Google C++ Style Guide के रूप में इनपुट/आउटपुट पैरामीटर के बारे में गाइड शैली इनपुट पैरामीटर के बीच स्पष्ट अंतर (सख्ती से cpplint.py के बाद) ड्रॉ (→ स्थिरांक रेफरी, मूल्य) और इनपुट-आउटपुट या आउटपुट मानकों (→ गैर स्थिरांक संकेत):

पैरामीटर से सी/सी ++ फ़ंक्शंस फ़ंक्शन में इनपुट होते हैं, फ़ंक्शन से आउटपुट आउटपुट होते हैं। इनपुट पैरामीटर आमतौर पर मान या कॉन्स्ट संदर्भ होते हैं, जबकि आउटपुट और इनपुट/आउटपुट पैरामीटर गैर-कॉन्स्ट पॉइंटर्स होंगे।

और आगे:

वास्तव में यह गूगल कोड में एक बहुत मजबूत परंपरा है कि इनपुट तर्क मान या स्थिरांक संदर्भ जबकि उत्पादन तर्क संकेत दिए गए हैं कर रहे हैं।

लेकिन मैं यह नहीं समझ सकता कि क्यों इनपुट/आउटपुट तर्क (मैं आउटपुट तर्कों को छोड़ देता हूं) संदर्भ द्वारा पारित नहीं किया जाना चाहिए। स्टैक ओवरफ्लो पर इस प्रश्न से संबंधित बहुत सारे विषय हैं: उदा। here, स्वीकार किए जाते हैं जवाब स्पष्ट रूप से कहना है कि

यह शैली

के बारे में ज्यादातर है, लेकिन है कि अगर

आप अशक्त पारित करने के लिए सक्षम होना चाहते हैं, तो आप एक सूचक का उपयोग करना चाहिए

तो, का बिंदु क्या है यदि मैं वाउ चाहता हूं तो सूचक की मांग करें पॉइंटर को शून्य से बचने के लिए एनटी? इनपुट तर्कों के लिए केवल संदर्भ का उपयोग क्यों करें?

Answer 1

मांग की है कि उत्पादन मानकों संकेत के रूप में पारित कर रहे हैं के लिए वजह साफ है:

यह यह स्पष्ट करता है कॉल साइट कि तर्क संभावित उत्परिवर्तित होने जा रही है पर:

foo(x, y);  // x and y won't be mutated 
bar(x, &y); // y may be mutated 

जब एक कोड आधार विकसित होता है और वृद्धिशील परिवर्तनों से गुजरता है जिनकी समीक्षा उन लोगों द्वारा की जाती है जो हर समय पूरे संदर्भ को नहीं जानते हैं, जितना जल्दी हो सके परिवर्तन के संदर्भ और प्रभाव को समझने में सक्षम होना महत्वपूर्ण है। तो इस शैली के शासन के साथ, यह तुरंत स्पष्ट हो जाता है कि कोई परिवर्तन एक उत्परिवर्तन प्रस्तुत करता है या नहीं।

Answer 2

बिंदु वे (जो मैं से असहमत) का कहना है कि मैं कुछ समारोह

void foo(int a, Bar* b); 

तो b तर्क वैकल्पिक है, या यह कभी कभी अनावश्यक है, तो आप ऐसा

की तरह समारोह कॉल कर सकते हैं है कर रहे हैं

foo(5, nullptr); 

समारोह

void foo(int a, Bar& b); 

गु के रूप में घोषित किया गया था, तो Bar में पास करने का कोई तरीका नहीं है।

यह बिंदु (जोर मेरा) पूरी तरह से राय आधारित है और डेवलपर के विवेकाधिकार तक है।

वास्तव में यह गूगल कोड में एक बहुत मजबूत परंपरा है कि इनपुट तर्क मान या स्थिरांक संदर्भ जबकि उत्पादन तर्क संकेत हैं कर रहे हैं।

यदि मैं आउटपुट पैरामीटर होने के लिए b का इरादा रखता हूं, तो इनमें से कोई भी पूरी तरह वैध और उचित है।

void foo(int a, Bar* b); // The version Google suggests 
void foo(int a, Bar& b); // Reference version, also perfectly fine. 

Answer 3

वे संभावना स्थिरता के लिए इसका इस्तेमाल करते हैं, क्योंकि वे उत्पादन पैरामीटर का उपयोग दोनों मौजूदा स्मृति के लिए संदर्भ (वे पहले से प्रारंभ चर संशोधित कर रहे हैं) के रूप में और वास्तविक उत्पादन (उत्पादन तर्क समारोह अपने आप में आवंटित करने के लिए ग्रहण कर रहे हैं के रूप में)। स्थिरता के लिए, वे इसे इनपुट बनाम आउटपुट को स्पष्ट रूप से इंगित करने के तरीके के रूप में उपयोग करते हैं।

यदि आपको आउटपुट पैरामीटर की स्मृति असाइन करने के लिए कभी भी फ़ंक्शन/विधि की आवश्यकता नहीं है, जैसे लुकअप से पॉइंटर लौटने या स्मृति को आवंटित करने और उसे पॉइंटर के माध्यम से लौटने की तरह, संदर्भों का उपयोग करें। यदि आपको ऐसा करने की ज़रूरत है लेकिन पैरामीटर इनपुट या आउटपुट के संकेत के रूप में कार्य करने के लिए पॉइंटर्स का उपयोग करने की परवाह नहीं करते हैं, तो उपयुक्त होने पर आउटपुट पैरामीटर के संदर्भों का उपयोग करें। सभी मामलों में पॉइंटर्स का उपयोग करने के लिए कोई पूर्ण आवश्यकता नहीं है जब तक कि उस कार्य/विधि की आवश्यकताओं को स्वयं की आवश्यकता न हो।

Answer 4

आप पहला सवाल कर रहे हैं: "तो, हमेशा इंगित क्या एक सूचक की मांग करता है, तो मैं सूचक से बचने के लिए null बनना चाहते हो?"

एक पॉइंटर का उपयोग करके कॉलर को घोषणा की जाती है कि उनके चर को संशोधित किया जा सकता है। अगर मैं foo(bar) पर कॉल कर रहा हूं, तो bar संशोधित होने जा रहा है? अगर मैं foo(&bar) पर कॉल कर रहा हूं तो यह स्पष्ट है कि bar का मान संशोधित किया जा सकता है।
वहाँ कार्य करता है जो एक null में एक वैकल्पिक उत्पादन पैरामीटर का संकेत के कई उदाहरण हैं

आपका दूसरा प्रश्न (मेरे सिर time के ऊपर से एक अच्छा उदाहरण है।): "क्यों केवल इनपुट तर्क के लिए संदर्भ का उपयोग"

एक संदर्भ पैरामीटर के साथ काम करना पॉइंटर तर्क के साथ काम करना आसान है।

int foo(const int* input){ 
    int return = *input; 

    while(*input < 100){ 
     return *= *input; 
     (*input)++; 
    } 
} 

इस कोड को एक संदर्भ के साथ फिर से लिखा लगता है कि:

int foo(const int& input){ 
    int return = input; 

    while(input < 100){ 
     return *= input; 
     input++; 
    } 
} 

आप देख सकते हैं कि एक const int& input का उपयोग कर कोड सरल करता है।