मुझे 'ऑटो' कीवर्ड को स्पष्ट रूप से लिखने की आवश्यकता क्यों है?

Question

मैं C ++ 98 से C ++ 11 की ओर बढ़ रहा हूं और autoकीवर्ड से परिचित हो गया हूं । मैं सोच रहा था कि autoकंपाइलर स्वचालित रूप से कटौती करने में सक्षम होने पर हमें स्पष्ट रूप से घोषित करने की आवश्यकता क्यों है । मुझे पता है कि सी ++ एक दृढ़ता से टाइप की गई भाषा है और यह एक नियम है लेकिन क्या एक ही परिणाम को स्पष्ट रूप से एक चर घोषित किए बिना प्राप्त करना संभव नहीं था auto?

Comments

याद रखें कि C परिवार संवेदनशील है। कुछ JS कोड पर जाएं जहां लेखक "var" को छोड़ देता है और "Bob", "bob" और "boob" जैसे नामों के साथ अलग-अलग चर का उपयोग करता है। ऊग।

— पीटीओटर

यहां तक ​​कि अगर यह संभव था तो यह एक मामूली भयानक विचार होगा। संभवतः पायथन (और इसी तरह की भाषाओं) की सबसे बड़ी कमजोरी एक घोषणा सिंटैक्स की कमी है। यह बग का एक प्रमुख स्रोत है कि सरल असाइनमेंट एक नया चर बनाएगा।

— कोनराड रुडोल्फ

@KonradRudolph: JS इसके घोषणा सिंटैक्स के साथ हालांकि बेहतर नहीं है। मुझे लगता है कि उनके कहने का मतलब यह था कि एक बारीक-बारीक अंदाज में एक चर के दायरे को सीमित करना अक्षमता है।

— user541686

@ मेहरदाद "शब्दार्थ" "अनिवार्य" बदलता है। समस्या यह है कि जावास्क्रिप्ट अंतर्निहित घोषणाओं को स्वीकार करता है । हां, वे शब्दार्थ रूप से भिन्न हैं, लेकिन इससे थोड़ी भी मदद नहीं मिलती है।

— कोनराड रुडोल्फ

यह भी देखें दोहरी सवाल मेरी "कीवर्ड" क्यों असली पर्ल उपयोगकर्ताओं का उपयोग करते हैं " stackoverflow.com/questions/8023959/why-use-strict-and-warnings/...

— यान टीएम

Answer 1

स्पष्ट छोड़ने से autoभाषा टूट जाएगी:

जैसे

int main()
{
    int n;
    {
        auto n = 0; // this shadows the outer n.
    }
}

जहां आप देख सकते हैं कि छोड़ने से बाहरी छायाauto नहीं होगी ।n

Comments

एक ही बात टाइप कर रहा था। आरंभीकरण से विभेदित असाइनमेंट को मानक के हिस्से पर एक मनमाना विकल्प की आवश्यकता होगी। चूंकि हमारे पास पहले से ही यह नियम है कि "कुछ भी जो एक घोषणा हो सकती है, एक घोषणा है", हम बहुत गंदे पानी में चलते हैं।

— स्टोरीटेलर - अनसलैंडर मोनिका

ये कोई समस्या नहीं है। गोलंग की तरह, आप स्पष्ट रूप से कुछ का उपयोग कर सकते हैं जैसे n := 0कि एक नया चर परिचय। क्यों autoप्रयोग किया जाता है एक राय आधारित प्रश्न है।

— llllllllll

@ लिलीसेंट - क्या यह राय आधारित है? (a) यह पहले से ही एक आरक्षित खोजशब्द था। (b) अर्थ काफी स्पष्ट है। (c) यह नए टोकन (जैसे :=) शुरू करने की आवश्यकता से बचा जाता है । (d) यह पहले से ही व्याकरण में फिट बैठता है। मुझे लगता है कि यहां राय के लिए बहुत कम जगह है।

— स्टोरीटेलर - अनसलैंडर मोनिका

@StoryTeller आपको नए टोकन की आवश्यकता नहीं है यदि x = f()एक नया चर घोषित किया जाता है (यदि अभी तक मौजूद नहीं है), तो एफ के रिटर्न मान के प्रकार प्राप्त करना ... ऑटो को स्पष्ट रूप से एक चर घोषित करने की आवश्यकता है, हालांकि, नए चर घोषित करने के जोखिम को कम करता है दुर्घटना से (जैसे एक टाइपो के कारण ...)।

— एकांकागुआ

@Aconcagua - "एक नया चर घोषित करता है (यदि अभी तक मौजूद नहीं है)" लेकिन छायांकन भाषा का हिस्सा है, और अभी भी काम करना चाहिए, जैसे कि बथशेबा दिखाता है। यह एक से अधिक बड़ी समस्या है जो एक कल्पना है। यह खरोंच से भाषा डिजाइन के बारे में नहीं है, यह एक जीवित साँस लेने की भाषा को बदलने के बारे में है। बहुत कठिन है करने के लिए। किंडा एक तेज रफ्तार कार पर पहिया बदलना पसंद करता है।

— स्टोरीटेलर - अनसलैंडर मोनिका

Answer 2

आपका प्रश्न दो व्याख्याओं की अनुमति देता है:

• हमें 'ऑटो' की आवश्यकता क्यों है? क्या हम बस इसे नहीं छोड़ सकते?
• हम ऑटो का उपयोग करने के लिए क्यों बाध्य हैं? क्या हमें इसका मतलब नहीं है, अगर यह नहीं दिया जाता है?

बतशेबा ने अच्छी तरह से पहली व्याख्या का जवाब दिया , दूसरे के लिए, निम्नलिखित पर विचार करें (अब तक कोई अन्य घोषणाएं मौजूद नहीं हैं; काल्पनिक रूप से मान्य सी ++):

int f();
double g();

n = f(); // declares a new variable, type is int;
d = g(); // another new variable, type is double

if(n == d)
{
    n = 7; // reassigns n
    auto d = 2.0; // new d, shadowing the outer one
}

यह संभव होगा , अन्य भाषाओं के साथ अच्छी तरह से दूर हो जाओ (अच्छी तरह से, छायांकन मुद्दे के अलावा शायद) ... यह सी ++ में ऐसा नहीं है, हालांकि, और सवाल (दूसरी व्याख्या के अर्थ में) अब है: क्यों ?

इस बार, पहली व्याख्या में उत्तर उतना स्पष्ट नहीं है। एक बात स्पष्ट है, हालांकि: कीवर्ड के लिए स्पष्ट आवश्यकता भाषा को सुरक्षित बनाती है (मुझे नहीं पता कि यह क्या है जिसने भाषा समिति को अपने निर्णय पर रोक दिया, फिर भी यह एक बिंदु है):

grummel = f();

// ...

if(true)
{
    brummel = f();
  //^ uh, oh, a typo...
}

क्या हम इस पर सहमत हो सकते हैं और किसी स्पष्टीकरण की आवश्यकता नहीं है?

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

_{( इसके महत्व के कारण 'psmears' टिप्पणी उद्धृत - इशारा करने के लिए धन्यवाद)}

Comments

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

— psmears

@psmears पायथन जैसी भाषाएं असाइनमेंट के लिए वैरिएबल / नॉनक्लॉक के रूप में वैरिएबल के स्पष्ट स्पेसिफिकेशन की आवश्यकता से बचती हैं; डिफ़ॉल्ट रूप से यह बस उस नाम के साथ एक नया स्थानीय चर बनाता है। (बेशक, आप global <variable>बयान की आवश्यकता के बिना एक वैश्विक चर से पढ़ सकते हैं ।) यह सी ++ भाषा के लिए और भी अधिक संशोधन की आवश्यकता होगी, ज़ाहिर है, इसलिए संभव नहीं होगा।

— JAB

@ जेएबी - हां, मुझे इस बारे में पता है ... मैंने इसका उल्लेख नहीं किया क्योंकि, जैसा कि आप कहते हैं, इसके लिए भाषा के लिए और भी अधिक संशोधन की आवश्यकता होगी :)

— भजन

एफडब्ल्यूआईडब्ल्यू, जो भाषा समिति को निकालता है, वह सबसे अधिक संभावित इतिहास है। AFAIK, जब सी मूल रूप से लिखा गया था, स्थानीय चर स्टैक पर सहेजे गए थे, और सी को सभी चर को स्पष्ट रूप से पहले एक ब्लॉक में घोषित करने की आवश्यकता थी। इसने संकलक को शेष कोड संकलित करने से पहले उस ब्लॉक के लिए भंडारण की आवश्यकता निर्धारित करने की अनुमति दी, और इसे स्टैक पर स्थान आवंटित करने के लिए सही निर्देश अनुक्रम जारी करने की अनुमति दी। MOV R6 R5 SUB #nnn R6R5 संभालने वाले PDP-11 पर IIRC को फ्रेम पॉइंटर के रूप में उपयोग किया जाता है और R6 स्टैक पॉइंटर है। nnn भंडारण की बाइट्स की संख्या की आवश्यकता है।

— 18'18

लोग पायथन का उपयोग करने का प्रबंधन करते हैं, जो हर बार एक असाइनमेंट के बाईं ओर एक नया नाम प्रकट होने पर एक चर घोषित करता है (भले ही वह नाम टाइपो हो)। लेकिन मैं इसे भाषा की अधिक गंभीर खामियों में से एक मानता हूं।

— होब्स

Answer 3

क्या स्पष्ट रूप से एक चर घोषित किए बिना एक ही परिणाम प्राप्त करना संभव नहीं था auto?

मैं आपके सवाल को थोड़ा इस तरह से बताने जा रहा हूँ जिससे आपको यह समझने में मदद मिलेगी कि आपको क्यों आवश्यकता है auto:

क्या स्पष्ट रूप से एक प्रकार के प्लेसहोल्डर का उपयोग किए बिना एक ही परिणाम प्राप्त करना संभव नहीं था ?

क्या यह संभव नहीं था ? बेशक यह "संभव" था। सवाल यह है कि क्या यह करने के प्रयास के लायक होगा।

अन्य भाषाओं में अधिकांश वाक्यविन्यास जो टाइपनेम नहीं करते हैं, एक दो तरीकों से काम करते हैं। गो-लाइक तरीका है, जहां name := value;एक चर घोषित किया जाता है। और पाइथन जैसा तरीका है, जहां पहले घोषित नहीं होने पर name = value;एक नया चर nameघोषित करता है।

मान लेते हैं कि C ++ में सिंटैक्स लागू करने के साथ कोई वाक्यविन्यास मुद्दे नहीं हैं (भले ही मैं पहले ही देख सकता हूं कि C ++ में identifierइसके बाद :"लेबल बनाएं" का अर्थ है)। तो, आप प्लेसहोल्डर्स की तुलना में क्या खो देते हैं?

खैर, मैं अब ऐसा नहीं कर सकता:

auto &name = get<0>(some_tuple);

देखें, autoहमेशा "मूल्य" का अर्थ है। यदि आप एक संदर्भ प्राप्त करना चाहते हैं, तो आपको स्पष्ट रूप से एक का उपयोग करने की आवश्यकता है &। और यह सही ढंग से संकलित करने में विफल हो जाएगा यदि असाइनमेंट अभिव्यक्ति एक प्रचलन है। न तो असाइनमेंट-आधारित सिंटैक्स में संदर्भ और मूल्यों के बीच अंतर करने का एक तरीका है।

अब, आप ऐसे असाइनमेंट सिंटैक्स को संदर्भों को घटा सकते हैं यदि दिए गए मान का संदर्भ है। लेकिन इसका मतलब यह होगा कि आप ऐसा नहीं कर सकते:

auto name = get<0>(some_tuple);

टपल से यह कॉपी करता है, जिससे एक स्वतंत्र वस्तु बनती है some_tuple। कभी-कभी, यही आप चाहते हैं। यह और भी उपयोगी है अगर आप टपल से आगे बढ़ना चाहते हैं auto name = get<0>(std::move(some_tuple));।

ठीक है, इसलिए शायद हम इन सिंटैक्स को इस अंतर के लिए थोड़ा बढ़ा सकते हैं। शायद &name := value;या &name = value;एक संदर्भ की तरह कटौती का मतलब होगा auto&।

अच्छी बात है। इस बारे में क्या:

decltype(auto) name = some_thing();

ओह ये सही हैं; सी ++ वास्तव में दो प्लेसहोल्डर हैं: autoऔरdecltype(auto) । इस कटौती का मूल विचार यह है कि यह ठीक वैसे ही काम करता है जैसे आपने किया था decltype(expr) name = expr;। तो हमारे मामले में, अगर some_thing()कोई वस्तु है , तो वह एक वस्तु को घटा देगा। यदि some_thing()एक संदर्भ है, तो यह एक संदर्भ काट देगा।

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

इसलिए अब हमें अपने सिंटैक्स में और अधिक जोड़ना होगा। name ::= value;"क्या decltype(auto)करता है" का अर्थ है। मेरे पास पाइथोनिक वैरिएंट के बराबर नहीं है।

इस वाक्यविन्यास को देखते हुए, क्या यह गलती से गलत प्रकार के लिए आसान नहीं है? इतना ही नहीं, यह शायद ही स्व-दस्तावेजीकरण है। यहां तक ​​कि अगर आपने पहले कभी नहीं देखा है decltype(auto), तो यह बड़ा और स्पष्ट है कि आप कम से कम आसानी से बता सकते हैं कि कुछ खास चल रहा है। जबकि दृश्य अंतर ::=और :=न्यूनतम है।

लेकिन यह राय सामान है; अधिक ठोस मुद्दे हैं। देखें, यह सब असाइनमेंट सिंटैक्स का उपयोग करने पर आधारित है। अच्छा ... उन जगहों के बारे में जो आप असाइनमेंट सिंटैक्स का उपयोग नहीं कर सकते हैं ? ऐशे ही:

for(auto &x : container)

क्या हम इसे बदल सकते हैं for(&x := container)? क्योंकि ऐसा लगता है कि रेंज-आधारित से बहुत अलग है for। ऐसा लगता है कि यह एक नियमित forलूप से इनिशलाइज़र स्टेटमेंट है , न कि रेंज-आधारित for। यह गैर-कटौती वाले मामलों से एक अलग वाक्यविन्यास भी होगा।

साथ ही, प्रतिलिपि-आरंभीकरण (उपयोग करना =) C ++ में प्रत्यक्ष-आरंभीकरण (निर्माण सिंटैक्स का उपयोग करके) के समान नहीं है। तो name := value;उन मामलों में काम नहीं कर सकता है जहां auto name(value)होगा।

निश्चित रूप से, आप घोषणा कर सकते हैं कि :=प्रत्यक्ष-आरंभीकरण का उपयोग करेगा, लेकिन यह बाकी सी + + के व्यवहार के तरीके के साथ काफी अनुरूप होगा।

इसके अलावा, एक और बात है: C ++ 14। इसने हमें एक उपयोगी कटौती सुविधा प्रदान की: वापसी प्रकार की कटौती। लेकिन यह प्लेसहोल्डर्स पर आधारित है। रेंज-बेस्ड की तरह for, यह मूल रूप से एक टाइपनेम पर आधारित होता है जो कंपाइलर द्वारा भरा जाता है, किसी विशेष नाम और अभिव्यक्ति के लिए लागू किए गए कुछ सिंटैक्स द्वारा नहीं।

देखें, ये सभी समस्याएं एक ही स्रोत से आती हैं: आप चर घोषित करने के लिए पूरी तरह से नए वाक्यविन्यास का आविष्कार कर रहे हैं। प्लेसहोल्डर-आधारित घोषणाओं को नए सिंटैक्स का आविष्कार नहीं करना पड़ा । वे पहले की तरह सटीक सिंटैक्स का उपयोग कर रहे हैं; वे सिर्फ एक नए कीवर्ड को नियोजित कर रहे हैं जो एक प्रकार की तरह कार्य करता है, लेकिन इसका एक विशेष अर्थ है। यह वही है जो इसे रेंज-आधारित forऔर वापसी प्रकार की कटौती के लिए काम करने की अनुमति देता है । यह वह है जो इसे कई रूपों ( autoबनाम decltype(auto)) के लिए अनुमति देता है । इत्यादि।

प्लेसहोल्डर काम करते हैं क्योंकि वे समस्या का सबसे सरल समाधान हैं, साथ ही साथ वास्तविक प्रकार के नाम का उपयोग करने के सभी लाभों और सामान्यता को बनाए रखते हैं। यदि आप एक और विकल्प के साथ आए, जो सार्वभौमिक रूप से प्लेसहोल्डर्स के रूप में काम करता है, तो यह अत्यधिक संभावना नहीं है कि यह प्लेसहोल्डर्स के रूप में सरल होगा।

जब तक कि यह अलग-अलग कीवर्ड या प्रतीकों के साथ सिर्फ प्लेसहोल्डर्स नहीं था ...

Comments

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

— llllllllll

@ लिलीसेंट: " जेनेरिक लैंबडा में टाइप डिडक्शन एक और उदाहरण हो सकता है। " मैंने इस बात का उल्लेख नहीं किया क्योंकि इसमें autoघोषणाओं / रिटर्न वैल्यू डिडक्शन से अलग शब्दार्थ है ।

— निकोल बोलस

@ लिलीसेंट: वास्तव में, यह उत्तर पार्टी के लिए देर से है। यूपीआई। (एक सुधार हालांकि सी ++ विचार यह है कि अगर कुछ का उल्लेख होगा सकता है तो यह एक घोषणा हो है एक घोषणा।)

— बतशेबा

Answer 4

संक्षेप में: autoकुछ मामलों में गिराया जा सकता है, लेकिन इससे असंगति पैदा होगी।

सबसे पहले, जैसा कि बताया गया है, सी ++ में घोषणा सिंटैक्स है <type> <varname>। स्पष्ट घोषणाओं के लिए कुछ प्रकार की आवश्यकता होती है या कम से कम एक घोषणा कीवर्ड की जगह होती है। इसलिए हम इस्तेमाल कर सकते हैं var <varname>या declare <varname>या कुछ और, लेकिन autoएक लंबे समय से कीवर्ड C ++ है, और स्वत: प्रकार कटौती कीवर्ड के अच्छे उम्मीदवार हैं।

क्या बिना सब कुछ तोड़कर असाइनमेंट द्वारा वेरिएबल घोषित करना संभव है?

कभी कभी हाँ। आप बाहर के कार्यों को असाइनमेंट नहीं कर सकते हैं, इसलिए आप वहां घोषणाओं के लिए असाइनमेंट सिंटैक्स का उपयोग कर सकते हैं। लेकिन इस तरह के दृष्टिकोण से भाषा में असंगतता आ जाएगी, संभवतः मानवीय त्रुटियों के लिए अग्रणी होगा।

a = 0; // Error. Could be parsed as auto declaration instead.
int main() {
  return 0;
}

और जब किसी भी तरह के स्थानीय चर की बात आती है तो स्पष्ट घोषणाएं होती हैं कि वे चर के दायरे को नियंत्रित करने का तरीका हैं।

a = 1; // use a variable declared before or outside
auto b = 2; // declare a variable here

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

Answer 5

autoएक ऐसा कीवर्ड है जिसका उपयोग आप उन जगहों पर कर सकते हैं जहाँ आपको आमतौर पर एक प्रकार निर्दिष्ट करने की आवश्यकता होती है ।

  int x = some_function();

intप्रकार को स्वचालित रूप से घटाकर अधिक सामान्य बनाया जा सकता है :

  auto x = some_function();

तो यह भाषा के लिए एक रूढ़िवादी विस्तार है; यह मौजूदा सिंटैक्स में फिट बैठता है। इसके बिना यह x = some_function()एक असाइनमेंट स्टेटमेंट बन जाता है, जो अब एक घोषणा नहीं है।

Answer 6

वाक्यविन्यास असंदिग्ध होना चाहिए और साथ ही पिछड़े संगत।

यदि ऑटो गिरा दिया जाता है तो बयानों और परिभाषाओं के बीच अंतर करने का कोई तरीका नहीं होगा।

auto n = 0; // fine
n=0; // statememt, n is undefined.

Comments

महत्वपूर्ण बिंदु यह है कि autoपहले से ही एक कीवर्ड था (लेकिन अप्रचलित अर्थ के साथ), इसलिए इसने नाम के रूप में इसका उपयोग करके कोड को नहीं तोड़ा। यह एक कारण है, जबकि एक बेहतर कीवर्ड, जैसे varया let, इसके बजाय उठाया नहीं गया था।

— Frax

@Frax IMO autoवास्तव में इसके लिए एक बहुत ही उत्कृष्ट कीवर्ड है: यह बिल्कुल वही व्यक्त करता है जो इसके लिए खड़ा है, अर्थात्, यह "स्वचालित प्रकार" के साथ एक प्रकार का नाम बदलता है। जैसे कीवर्ड के साथ varया let, आपको फलस्वरूप स्पष्ट रूप से कीवर्ड की आवश्यकता होती है, भले ही वह प्रकार स्पष्ट रूप से निर्दिष्ट किया गया हो, var int n = 0या जैसे कुछ var n:Int = 0। यह मूल रूप से रस्ट में कैसे किया जाता है।

— 18:30

@leftaroundabout जबकि autoनिश्चित रूप से मौजूदा वाक्य रचना के संदर्भ में उत्कृष्ट है, मैं की तरह है कि कुछ कहेंगे var int x = 42, बुनियादी चर परिभाषा होने के साथ var x = 42और int x = 42shorthands के रूप में, वर्तमान वाक्य रचना की तुलना में अधिक मतलब होता अगर ऐतिहासिक सामग्री से बाहर माना। लेकिन यह ज्यादातर स्वाद की बात है। लेकिन, आप सही हैं, मुझे अपनी मूल टिप्पणी में "एक कारण" के बजाय "एक कारण"

— लिखना चाहिए था

@leftractionabout: "ऑटो वास्तव में इसके लिए एक बहुत ही उत्कृष्ट कीवर्ड है: यह बिल्कुल वही व्यक्त करता है जो इसके लिए खड़ा है, अर्थात्, यह 'स्वचालित प्रकार' के साथ एक प्रकार का नाम बदलता है" यह सच नहीं है। कोई "स्वचालित प्रकार" नहीं है।

— कक्षा

@LightnessRacesinOrbit किसी भी संदर्भ में जिसमें आप उपयोग कर सकते हैं auto, एक स्वत: प्रकार (एक अलग, अभिव्यक्ति पर निर्भर करता है) है।

— लेफ्टनैताबाउट

Answer 7

पिछले उत्तरों में जोड़कर, एक पुराने गोज़ से एक अतिरिक्त नोट: ऐसा लगता है कि आप इसे एक नए चर का उपयोग करने में सक्षम होने के लिए किसी भी तरह से घोषित किए बिना एक लाभ के रूप में देख सकते हैं।

चरों की निहित परिभाषा की संभावना वाली भाषाओं में यह एक बड़ी समस्या हो सकती है, विशेष रूप से बड़ी प्रणालियों में। आप एक टाइपो बनाते हैं और आप घंटों तक डिबग करते हैं केवल यह जानने के लिए कि आपने अनायास शून्य (या बदतर) - blueबनाम bleu, labelबनाम के मूल्य के साथ एक चर पेश किया है lable... इसका परिणाम यह है कि आप वास्तव में किसी भी कोड पर सटीक जाँच किए बिना भरोसा नहीं कर सकते। चर नाम।

बस autoसंकलक और अनुरक्षक दोनों का उपयोग करके बताता है कि एक नया चर घोषित करना आपका उद्देश्य है।

इसके बारे में सोचें, इस तरह के बुरे सपने से बचने में सक्षम होने के लिए 'निहित कोई नहीं' कथन फोरट्रान में पेश किया गया था - और आप इसे आजकल सभी गंभीर फोरट्रान कार्यक्रमों में उपयोग करते हैं। यह नहीं है बस ... डरावना है।