C / C ++ में, क्या संभव होने पर मुझे मापदंडों और स्थानीय चर में 'const' का उपयोग करना चाहिए?

Question

यह प्रश्न जावा में एकfinal प्रश्न से प्रेरित है ।

C / C ++ में, क्या मुझे constजब भी संभव हो उपयोग करना चाहिए ?

मुझे पता है कि मापदंडों में उपयोग करनेconst के बारे में पहले से ही एक संबंधित प्रश्न है । दुर्भाग्य से यह सवाल है और यह जवाब पूरी तरह से मेरे सवाल का जवाब नहीं है, क्योंकि यह केवल फ़ंक्शन मापदंडों के बारे में है, लेकिन मैं अन्य मामलों के बारे में भी जानना चाहूंगा (जैसे: स्थानीय चर)।

साथ ही, उस प्रश्न के लगभग सभी उत्तरों का कहना है कि हमें इसका उपयोग करना चाहिए constक्योंकि इसमें चर की पहुंच के बारे में उपयोगी जानकारी है। लेकिन यह जावा में फाइनल का उपयोग करने के बारे में एक उत्तर के साथ संघर्ष करने के लिए लगता है जो राज्यों finalको अतिशयोक्तिपूर्ण हो सकता है यदि इसमें अतिरिक्त जानकारी नहीं है और इसलिए इसे कोड को छोटा और साफ रखने के लिए छोड़ दिया जाना चाहिए।

तो, क्या मुझे constजब भी संभव हो उपयोग करना चाहिए ? यदि हां, तो constC ++ finalमें जावा के लिए सलाह से भिन्न क्यों है ?

Answer 1

सबसे पहले, चूंकि आपने जावा का संदर्भ दिया है, इसलिए finalयह पूरी तरह से अलग जानवर है const। अंतिम का अर्थ है कि संदर्भ बदल नहीं सकता है, लेकिन परिवर्तनशीलता के बारे में कुछ नहीं कहता है। कॉन्स्ट "एक कॉस्ट रेफरेंस म्यूट नहीं कर सकता" कहकर आगे बढ़ता है जो बहुत मजबूत गारंटी है। जावा में ऐसा करने के लिए, आंतरिक स्थिति को अंतिम होना चाहिए और निर्माण समय पर निर्धारित किया जाना चाहिए। कॉन्स्ट का उपयोग करना बहुत आसान है, और एक मौजूदा ऑब्जेक्ट को एक कॉन्स्टेंस रेफरेंस में "प्रचारित" किया जा सकता है।

हां, जब भी संभव हो आप कास्ट का उपयोग करें। यह एक अनुबंध करता है कि आपका कोड कुछ नहीं बदलेगा। याद रखें, एक नॉन-कास्ट वैरिएबल एक फंक्शन में पास किया जा सकता है जो एक कास्ट पैरामीटर स्वीकार करता है। आप हमेशा कास्ट जोड़ सकते हैं, लेकिन इसे दूर न करें (कॉस्ट कास्ट के बिना नहीं जो वास्तव में बुरा विचार है)।

कब्ज-शुद्धता कई बार थकाऊ हो सकती है, लेकिन यह अपरिवर्तनीयता की गारंटी देने में मदद करती है। यह बहु-थ्रेडेड कोड में महत्वपूर्ण है जहां थ्रेड्स ऑब्जेक्ट साझा करते हैं। यह कुछ कार्यों को अधिक कुशल बनाता है: राज्य की नकल करने के बजाय, उसी अपरिवर्तनीय वस्तु का पुन: उपयोग करें। लाइब्रेरी प्रोग्रामर को गारंटी प्रदान करने के लिए पुस्तकालयों में कसौटियों को स्वीकार कर सकते हैं कि नहीं, आपकी वस्तु ब्लैक होल में अप्रत्याशित तरीके से नहीं बदलेगी जो कि लाइब्रेरी की हिम्मत है।

Comments

वोट ऊपर हैं क्योंकि आप उस समझाने finalऔर constएक ही गारंटी नहीं है।

— बिल डोर

स्थिरता लेखन क्षमता के बारे में है, न कि पारस्परिकता के बारे में।

— बसिलेवस

@Basilevs यदि आप किसी वस्तु पर लिखते हैं तो क्या होता है? यह उत्परिवर्तित करता है। आप किसी ऑब्जेक्ट को कैसे म्यूट करते हैं? इसे लिखें।

यदि आप एक कॉस्ट संदर्भ में लिखते हैं तो क्या होगा? एक संकलन समय त्रुटि। यदि आप उस वस्तु को लिखते हैं जो किसी अन्य नॉन-कॉन्स्टेक्ट संदर्भ के माध्यम से कहीं और संदर्भित होती है? यह उत्परिवर्तित करता है। अपरिवर्तनीय वस्तु उत्परिवर्तित नहीं कर सकती है, इसलिए कॉन्स्ट रेफरेंस अपरिवर्तनीय वस्तु को संदर्भित नहीं करता है।

— बसिलेव्स

@ बिसिलेव्स आपका अवलोकन केवल कॉन्स्टेंस रिफल्स के साथ लागू होता है। यदि कोई वस्तु अपने आप में नक्षत्र घोषित हो जाती है (केवल संदर्भ नहीं) तो यह अधिक या कम अपरिवर्तनीय है (जब तक कि कोई व्यक्ति अपरिचित रूप से कब्ज को दूर नहीं करता)।

— मैथ्यू जेम्स ब्रिग्स

Answer 2

व्यक्तिगत रूप से, constमुझे लिखने के लिए बहुत कम समय लगता है, और पढ़ने के लिए बहुत कम समय, आमतौर पर यह जांचने के लिए बहुत कम होता है कि क्या कोई कोड चर को उत्परिवर्तित करता है या नहीं, और यह वास्तव में मुझे कीड़े लिखने से रोकता है (किसी ने कभी भी दुर्घटना से अपने अंतिम पुनरावृत्ति को बढ़ाया है? आदि)

मुझे यह भी पता चलता है कि कांस्टेबल उपयोग के बारे में सख्त होना मुझे अन्य तरीकों से बेहतर कोड की ओर निर्देशित करता है, जैसे कि गैर-तुच्छ आरंभीकरण करने के लिए सहायक कार्य बनाना।

Answer 3

मैं अन्य पोस्टरों से असहमत होने जा रहा हूं और आपको स्थानीय चर और मापदंडों पर शीर्ष-स्तर का उपयोग नहीं करने की सलाह देता हूं const। (संदर्भ और संकेत के आधार पर, यानी const T&, अलग-अलग हैं, और आपको उपयुक्त होने पर हर समय शुद्धता के लिए उनका उपयोग करना चाहिए।)

शीर्ष स्तर के फायदे constहैं:

• यह स्पष्ट करता है कि स्थानीय चर को उत्परिवर्तित करने के लिए नहीं हैं।
• यदि आप गलती से उन्हें म्यूट करने का प्रयास करते हैं तो संकलक त्रुटि देता है।

नुकसान हैं:

• दृश्य अव्यवस्था।

• "छद्म-कास्ट" चर पर उपयोग नहीं किया जा सकता है, अर्थात चर जो प्रत्यक्ष निर्माण की तुलना में अधिक जटिल हैं, लेकिन बाद में संशोधित नहीं किया गया है, उदाहरण के लिए getline:

  std::string line; // cannot be const
  std::getline(std::cin, line);
  // line should be const from here on out

• फ़ंक्शन कॉल और वापसी पर चाल-आउट अनुकूलन को रोकता है:

  std::string f1();
  std::string f2(std::string s);
  std::string f3() {
    const std::string s = f1(); // s is not meant to be modified
    // but I still want the move optimization here:
    const std::string result = f2(std::move(s)); // this doesn't move
    // and I want the compiler to move out here:
    return result; // this will probably RVO, but if not, the move
                   // constructor will not be used due to the const
  }

मैंने एक कोडबेस पर काम किया है, जहां स्थानीय constका बहुत उपयोग किया गया था, और मैंने पाया कि यह बिल्कुल भी मददगार नहीं है, फिर भी इसने उपरोक्त के रूप में सूक्ष्म निराशावाद के साथ कोड को भरा। मैं व्यक्तिगत रूप से संभव के रूप में शायद ही चर को संशोधित करने की एक सामान्य नीति अपनाना चाहता हूं, और कार्यों को इतना छोटा बनाना कि एक चर का उपयोग स्पष्ट हो, और भले ही इसे संशोधित किया गया हो, फ़ंक्शन की जटिलता इसे कम करने के लिए पर्याप्त नहीं है -मुद्दा।

Comments

चाल-से के बारे में आपकी बात यह दिखा रही है कि आप स्थानीय

— कांस्टेबल

@ कैलेथ नहीं, यह बात है। मैं इसे संशोधित करने का इरादा नहीं करता। मैं बस मान पास करना चाहता हूं, या इसे वापस करना चाहता हूं, और मैं चाहता हूं कि यह कुशल हो। वैचारिक रूप से, संशोधन सिर्फ एक अनुकूलन है, जिसका अर्थ है कि अवलोकन योग्य नहीं है (क्योंकि चर बाद में उपयोग नहीं किए जाते हैं)। व्यावहारिक रूप से, हाँ, एक संशोधन है, क्योंकि C ++ में सही विनाशकारी चालें नहीं हैं (जैसे रस्ट है)। यही कारण है कि मैं constस्थानीय लोगों पर नहीं चाहता : क्योंकि यह तकनीकी संशोधनों को रोकता है, न कि केवल वैचारिक संशोधनों को।

— सेबेस्टियन रेडल

आप मान को संशोधित नहीं करना चाहते हैं , लेकिन आप चर को संशोधित करना चाहते हैं । आप इसके बजाय const और बजाय का उपयोग कर सकते हैं, और न ही संशोधित कर सकते हैं

— Caleth

Answer 4

constकीवर्ड सिर्फ मानकों की तरह, स्थानीय चर के लिए इस्तेमाल किया जाना चाहिए। यह उपयोगी है क्योंकि:

• कोड पढ़ने में आसान। जब कोई परिवर्तनशील घोषणा को पढ़ता है, तो वह जानती है कि यह नहीं बदलेगा। अपने कोड को पढ़ते समय चिंता करने वाली एक कम बात।
• रोकें आप गलती से परिवर्तनशील चर
• रनटाइम पेनल्टी नहीं, सब कुछ स्टेटिकली चेक किया जाता है। यह एक मुफ्त दोपहर के भोजन की तरह है, constलिखने के लिए बस एक सेकंड लेना चाहिए, इसलिए यह कोई बड़ी बात नहीं है।
• अपने बहु-थ्रेडेड अनुप्रयोगों में अपने चर / मापदंडों को बनाना हमेशा एक अच्छा विचार है। यहां तक ​​कि आपका एप्लिकेशन बहु-थ्रेडेड नहीं है, फिर भी यह एक अच्छी आदत है।
• आप अपने कोड को अनुकूलित करने के लिए अपने C ++ कंपाइलर के लिए एक अवसर देते हैं।

ध्यान दें कि यहाँ कोई सही / गलत उत्तर नहीं है। आपके लिंक में, उत्तर देने वाले के पास सबसे अधिक अपवित्र तर्क थे finalजिनका उपयोग स्थानीय रूप से नहीं किया जाना चाहिए। हालांकि, अगले उत्तरदाता ने इसकी जोरदार सिफारिश की।

यदि आपका कार्य सरल और तुच्छ है , तो आपको नहीं जोड़ना चाहिए constक्योंकि हर कोई आपके इरादे को समझता है। हालाँकि, यदि आपके फ़ंक्शन में तर्क गैर-तुच्छ है, तो आपको कीवर्ड का उपयोग करना चाहिए। याद रखें, खोने के लिए बहुत कम है।