डिफ़ॉल्ट रूप से NULL के साथ प्रारंभिक संकेत क्यों नहीं दिए गए हैं?

Question

क्या कोई यह बता सकता है कि पॉइंटर्स को इनिशियलाइज़ क्यों नहीं किया जाता है NULL?
उदाहरण:

  void test(){
     char *buf;
     if (!buf)
        // whatever
  }

यदि इस कार्यक्रम के अंदर कदम नहीं होगा क्योंकि buf यह शून्य नहीं है ।

मैं यह जानना चाहूंगा कि क्यों, किस मामले में हमें ट्रैश पर एक चर की आवश्यकता है, विशेष रूप से पॉइंटर्स मेमोरी पर कचरा को संबोधित करते हैं?

Comments

ठीक है, क्योंकि मौलिक प्रकारों को अनधिकृत छोड़ दिया जाता है। इसलिए मैं आपके "वास्तविक" प्रश्न को मानता हूं: मौलिक प्रकारों को प्रारंभिक क्यों नहीं किया जाता है?

— GManNickG

"यदि बफ़र अशक्त नहीं है तो प्रोग्राम अंदर नहीं जाएगा"। यह सही नहीं है। चूँकि आप नहीं जानते कि buf क्या है , आप यह नहीं जान सकते कि यह क्या नहीं है ।

— ड्रू डॉर्मन

जावा जैसी किसी चीज के विपरीत, C ++ डेवलपर को एक टन अधिक जिम्मेदारी देता है।

— ऋषि

पूर्णांक, पॉइंटर्स, डिफॉल्ट 0 यदि आप कंस्ट्रक्टर () का उपयोग करते हैं।

— एरिक एरोनिटी

इस धारणा के कारण कि C ++ का उपयोग करने वाला कोई व्यक्ति यह जान रहा है कि वे क्या कर रहे हैं, किसी ऐसे व्यक्ति को, जो स्मार्ट पॉइंटर पर कच्चे पॉइंटर्स का उपयोग कर रहा है, वह जानता है (और भी बहुत कुछ) जो वे कर रहे हैं!

— लॉफ्टी लायन

Answer 1

हम सभी को पता चलता है कि सूचक (और अन्य POD प्रकार) को आरंभीकृत किया जाना चाहिए।
सवाल तो यह हो जाता है कि 'उन्हें किसकी शुरुआत करनी चाहिए'।

वैसे मूल रूप से दो तरीके हैं:

• संकलक उन्हें आरंभ करता है।
• डेवलपर उन्हें आरंभ करता है।

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

तो अब हमारे पास ऐसी स्थिति है कि संकलक ने कोड के लिए एक अतिरिक्त निर्देश जोड़ा है जो चर को NULL से आरंभ करता है और बाद में डेवलपर कोड को सही आरंभीकरण करने के लिए जोड़ा जाता है। या अन्य शर्तों के तहत चर का उपयोग संभवतः कभी नहीं किया जाता है। बहुत से C ++ डेवलपर्स उस अतिरिक्त निर्देश की कीमत पर दोनों स्थितियों में बेईमानी चिल्लाएंगे।

यह सिर्फ समय की बात नहीं है। बल्कि स्पेस भी। बहुत सारे वातावरण हैं जहां दोनों संसाधन प्रीमियम पर हैं और डेवलपर्स या तो छोड़ना नहीं चाहते हैं।

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

Comments

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

— बिल IV

आप आश्चर्यचकित होंगे कि कितने लोग केवल किसी को अपने सभी आरंभीकरण को ठीक करने से बचेंगे। यह थकाऊ काम होगा अगर यह संकलक चेतावनी के लिए नहीं था।

— जोनाथन हेंसन

@ लोकी, मुझे आपकी बात मानकर कठिन समय हो रहा है। मैं आपके उत्तर को मददगार मानने की कोशिश कर रहा था, मुझे आशा है कि आपने उसे इकट्ठा किया है। अगर नहीं तो मुझे खेद है।

— जोनाथन हेंसन

यदि पॉइंटर पहले NULL पर सेट है और फिर जो भी मान पर सेट है, कंपाइलर को इसका पता लगाने और पहले NULL इनिशियलाइज़ेशन को ऑप्टिमाइज़ करने में सक्षम होना चाहिए, है ना?

— कोर्चकिडु

@ कोर्चकिडु: कभी-कभी। हालांकि एक बड़ी समस्या यह है कि इसके लिए कोई रास्ता नहीं है कि आपको यह बताए कि आप अपना आरंभ करना भूल गए हैं, क्योंकि यह नहीं जान सकता है कि डिफ़ॉल्ट आपके उपयोग के लिए सही नहीं है।

— Deduplicator

Answer 2

टीसी ++ पीएल (विशेष संस्करण p.22) में बज़्ने स्ट्रॉस्ट्रुप का उद्धरण:

एक विशेषता के कार्यान्वयन को उन कार्यक्रमों पर महत्वपूर्ण ओवरहेड्स को लागू नहीं करना चाहिए जिन्हें इसकी आवश्यकता नहीं है।

Comments

और विकल्प भी न दें। ऐसा लगता है

— योनातन

@ जोनाथन कुछ भी नहीं सूचक को प्रारंभिक अशक्त करने से रोकता है - या C ++ में मानक के रूप में।

— stefanB

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

— राबर्ट टक

यह अनुकूलता को नहीं तोड़ता है। विचार को "int * x = __uninitialized" के साथ संयोजन में माना गया है - डिफ़ॉल्ट रूप से सुरक्षा, इरादे से गति।

— MSalters

मुझे क्या पसंद Dहै। यदि आप नहीं चाहते हैं कि आरंभीकरण इस वाक्यविन्यास का उपयोग करे float f = void;या int* ptr = void;। अब यह डिफ़ॉल्ट रूप से आरंभिक है लेकिन अगर आपको वास्तव में जरूरत है तो आप कंपाइलर को ऐसा करने से रोक सकते हैं।

— deft_code

Answer 3

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

int * p = & some_int;

या:

int * p = 0;

या:

class A {
   public:
     A() : p( 0 ) {}  // initialise via constructor
   private:
     int * p;
};

Comments

k, यदि इनिशियलाइज़ेशन में समय लगता है और मैं अभी भी यही चाहता हूँ, तो किसी भी तरह से अपने पॉइंटर्स को मैन्युअल रूप से सेट किए बिना अशक्त बनाने के लिए कितना सही है? देखिए, इसलिए नहीं कि मैं इसे ठीक नहीं करना चाहता, क्योंकि मुझे लगता है कि मैं कभी भी यूनिटीलॉइज्ड पॉइंटर्स का उपयोग अपने पते पर कचरा के साथ नहीं करूंगा

— जोनाथन

आप क्लास के कंस्ट्रक्टर में क्लास मेंबर्स को इनिशियलाइज़ करते हैं - यही C ++ काम करता है।

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

— DrPindra

Nnull के लिए प्रारंभिक एपनॉइंटर करना एक समझदारी की बात हो सकती है। और ऐसे कई ऑपरेशन हैं जो आप अशक्त बिंदुओं पर कर सकते हैं - आप उनका परीक्षण कर सकते हैं और आप उन पर डिलीट कॉल कर सकते हैं।

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

— डेविड थॉर्नले

Answer 4

चूँकि C ++ का एक मोटो है:

---

आप जो उपयोग नहीं करते हैं उसके लिए आप भुगतान नहीं करते हैं

---

यह बहुत ही कारण के लिए, operator[]के vectorवर्ग की जाँच नहीं करता है, तो सूचकांक, सीमा से बाहर है, उदाहरण के लिए।

Answer 5

ऐतिहासिक कारणों से, मुख्य रूप से ऐसा इसलिए है क्योंकि यह सी में किया जाता है। सी में ऐसा क्यों किया जाता है, यह एक और सवाल है, लेकिन मुझे लगता है कि शून्य ओवरहेड सिद्धांत इस डिजाइन निर्णय में किसी भी तरह शामिल था।

Comments

मुझे लगता है कि सी को स्मृति (उर्फ पॉइंटर्स) तक आसान पहुंच के साथ निचले स्तर की भाषा माना जाता है, इसलिए यह आपको वह स्वतंत्रता देता है जो आप चाहते हैं और हर चीज को शुरू करके ओवरहेड को लागू नहीं करते हैं। BTW मुझे लगता है कि यह प्लेटफ़ॉर्म पर निर्भर करता है क्योंकि मैंने लिनक्स आधारित मोबाइल प्लेटफ़ॉर्म पर काम किया था जो कि सभी को 0 से मेमोरी करता है ताकि उपयोग करने से पहले सभी वेरिएबल्स 0. पर सेट हो जाएं

— stefanB

Answer 6

इसके अलावा, जब आप इसे उड़ाते हैं तो हमारे पास एक चेतावनी होती है: "संभवतः आपके संकलक के आधार पर" एक मान निर्दिष्ट किए जाने से पहले "या इसी तरह की क्रिया का उपयोग किया जाता है।

आप चेतावनी के साथ संकलन करते हैं, है ना?

Comments

और यह केवल एक आरोप के रूप में संभव है कि संकलक अनुरेखण दोषपूर्ण हो सकता है।

— डेडुप्लिकेटर

Answer 7

ऐसी कुछ स्थितियाँ लुप्त हो जाती हैं जिनमें यह कभी समझ में आता है कि परिवर्तनशील होने के लिए एक चर है, और डिफ़ॉल्ट-आरंभीकरण की एक छोटी सी लागत है, तो यह क्यों होता है?

C ++ C89 नहीं है। नरक, सी भी C89 नहीं है। आप घोषणाओं और कोड को मिला सकते हैं, इसलिए आपको ऐसे समय तक घोषणा को स्थगित करना चाहिए जब तक कि आपके पास शुरू करने के लिए उपयुक्त मूल्य न हो।

Comments

फिर बस हर मूल्य को दो बार लिखना होगा - एक बार संकलक की नियमित दिनचर्या के द्वारा, और फिर उपयोगकर्ता के कार्यक्रम द्वारा। आम तौर पर एक बड़ी समस्या नहीं है, लेकिन यह आगे बढ़ता है (जैसे कि यदि आप 1 मिलियन वस्तुओं की एक सरणी बना रहे हैं)। यदि आप ऑटो-इनिशियलाइज़ेशन चाहते हैं, तो आप हमेशा अपने स्वयं के प्रकार बना सकते हैं जो ऐसा करते हैं; लेकिन इस तरह आप अनावश्यक ओवरहेड को स्वीकार करने के लिए मजबूर नहीं हैं यदि आप नहीं करना चाहते हैं।

— जेरेमी फ्रिस्नर

Answer 8

एक सूचक सिर्फ एक और प्रकार है। यदि आप एक int, charया किसी अन्य POD प्रकार का निर्माण करते हैं, तो इसे शून्य पर आरंभीकृत नहीं किया जाता है, तो एक सूचक क्यों होना चाहिए? यह किसी के लिए अनावश्यक उपरि माना जा सकता है जो इस तरह का कार्यक्रम लिखता है।

char* pBuf;
if (condition)
{
    pBuf = new char[50];
}
else
{
    pBuf = m_myMember->buf();
}

यदि आप जानते हैं कि आप इसे शुरू करने जा रहे हैं, तो जब आप पहली बार pBufविधि के शीर्ष पर बनाते हैं , तो प्रोग्राम को लागत क्यों लगानी चाहिए ? यह शून्य ओवरहेड सिद्धांत है।

Comments

दूसरी ओर आप चार * pBuf = शर्त कर सकते हैं? new char [50]: m_myMember-> buf (); यह सिंटैक्स की बात है फिर दक्षता की तरह लेकिन मैं फिर भी आपसे सहमत हूँ।

— the_drow

@the_drow: ठीक है, कोई इसे और अधिक जटिल बना सकता है, इसलिए ऐसा पुनर्लेखन संभव नहीं है।

— Deduplicator

Answer 9

यदि आप एक ऐसा पॉइंटर चाहते हैं जो हमेशा NULL के लिए इनिशियलाइज़ हो, तो आप उस कार्यक्षमता का अनुकरण करने के लिए C ++ टेम्पलेट का उपयोग कर सकते हैं:

template<typename T> class InitializedPointer
{
public:
    typedef T       TObj;
    typedef TObj    *PObj;
protected:
    PObj        m_pPointer;

public:
    // Constructors / Destructor
    inline InitializedPointer() { m_pPointer=0; }
    inline InitializedPointer(PObj InPointer) { m_pPointer = InPointer; }
    inline InitializedPointer(const InitializedPointer& oCopy)
    { m_pPointer = oCopy.m_pPointer; }
    inline ~InitializedPointer() { m_pPointer=0; }

    inline PObj GetPointer() const  { return (m_pPointer); }
    inline void SetPointer(PObj InPtr)  { m_pPointer = InPtr; }

    // Operator Overloads
    inline InitializedPointer& operator = (PObj InPtr)
    { SetPointer(InPtr); return(*this); }
    inline InitializedPointer& operator = (const InitializedPointer& InPtr)
    { SetPointer(InPtr.m_pPointer); return(*this); }
    inline PObj operator ->() const { return (m_pPointer); }
    inline TObj &operator *() const { return (*m_pPointer); }

    inline bool operator!=(PObj pOther) const
    { return(m_pPointer!=pOther); }
    inline bool operator==(PObj pOther) const
    { return(m_pPointer==pOther); }
    inline bool operator!=(const InitializedPointer& InPtr) const
    { return(m_pPointer!=InPtr.m_pPointer); }
    inline bool operator==(const InitializedPointer& InPtr) const
    { return(m_pPointer==InPtr.m_pPointer); }

    inline bool operator<=(PObj pOther) const
    { return(m_pPointer<=pOther); }
    inline bool operator>=(PObj pOther) const
    { return(m_pPointer>=pOther); }
    inline bool operator<=(const InitializedPointer& InPtr) const
    { return(m_pPointer<=InPtr.m_pPointer); }
    inline bool operator>=(const InitializedPointer& InPtr) const
    { return(m_pPointer>=InPtr.m_pPointer); }

    inline bool operator<(PObj pOther) const
    { return(m_pPointer<pOther); }
    inline bool operator>(PObj pOther) const
    { return(m_pPointer>pOther); }
    inline bool operator<(const InitializedPointer& InPtr) const
    { return(m_pPointer<InPtr.m_pPointer); }
    inline bool operator>(const InitializedPointer& InPtr) const
    { return(m_pPointer>InPtr.m_pPointer); }
};

Comments

अगर मैं इसे लागू कर रहा था, मैं टी कॉपी ctor या असाइनमेंट सेशन से परेशान नहीं करूंगा - चूक काफी ठीक हैं। और आपका नाश करने वाला व्यर्थ है। आप निश्चित रूप से कुछ परिस्थितियों में ओपेरा एट कम से कम का उपयोग करके पॉइंटर्स का परीक्षण कर सकते हैं) इसलिए आपको उन्हें प्रदान करना चाहिए।

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

— अदिसक

ओके ने सभी तुलना ऑपरेटरों को जोड़ा। डिफ़ॉल्ट ओवरराइड निरर्थक हो सकता है लेकिन वे यहां स्पष्ट रूप से हैं क्योंकि यह एक उदाहरण है।

— अदिसक

मैं समझ नहीं पा रहा था कि यह सभी बिंदुओं को बिना मैन्युअल रूप से सेट किए कैसे अशक्त कर देगा, क्या आप बता सकते हैं कि यू ने यहां क्या किया?

— जोनाथन

@ जोनाथन: यह मूल रूप से एक "स्मार्ट पॉइंटर" है जो पॉइंटर को अशक्त करने के अलावा और कुछ नहीं करता है। IE के बजाय Foo *a, आप का उपयोग करें InitializedPointer<Foo> a- Foo *a=0कम टाइपिंग के रूप में एक विशुद्ध रूप से अकादमिक उत्कृष्टता है। हालाँकि, ऊपर दिया गया कोड एक शैक्षिक दृष्टिकोण से बहुत उपयोगी है। थोड़ा संशोधन ("प्लेसहोल्डिंग" ctor / dtor और असाइनमेंट ऑप्स के साथ), यह आसानी से स्कोप-पॉइंटर्स (जो कि डिस्ट्रक्टर पर मुक्त होता है) और संदर्भ-गिनती-पॉइंटर्स सहित inc / जोड़कर विभिन्न प्रकार के स्मार्ट पॉइंटर्स तक बढ़ाया जा सकता है। जब m_pPointer सेट या क्लियर हो जाता है, तो ऑपरेशन से कम करें।

— अदिसक

Answer 10

ध्यान दें कि स्थैतिक डेटा 0 से प्रारंभ होता है (जब तक कि आप अन्यथा न कहें)।

और हां, आपको हमेशा अपने चर को देर से और प्रारंभिक मूल्य के साथ घोषित करना चाहिए। कोड की तरह

int j;
char *foo;

जब आप इसे पढ़ते हैं तो अलार्म घंटियाँ सेट करें। मुझे नहीं पता कि क्या कोई लिंट एस को इसके बारे में कार्प करने के लिए राजी किया जा सकता है, हालांकि यह 100% कानूनी है।

Comments

क्या वह गारंटेड है, या आज के समय के कंपाइलरों द्वारा उपयोग किया जाने वाला एक सामान्य अभ्यास है?

— gha.st

स्टैटिक वेरिएबल्स को 0 से इनिशियलाइज़ किया जाता है, जो पॉइंटर्स के लिए भी सही काम करता है (यानी, उन्हें NULL को सेट करता है, सभी बिट्स 0 को नहीं)। यह व्यवहार मानक द्वारा गारंटीकृत है।

— आलोक सिंघल

शून्य के लिए स्थैतिक डेटा की आरंभीकरण की गारंटी C और C ++ मानक द्वारा दी जाती है, यह सिर्फ सामान्य अभ्यास नहीं है

— groovingandi

शायद इसलिए कि कुछ लोग यह सुनिश्चित करना चाहते हैं कि उनके स्टैक को अच्छी तरह से संरेखित किया गया है ताकि वे फ़ंक्शन के शीर्ष पर सभी चर घोषित कर सकें? शायद वे एसी बोली में लिख रहे हैं कि यह आवश्यक है?

— KitsuneYMG

Answer 11

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

वास्तव में, संक्षेप में, वे इस अर्थ में आरंभिक हैं कि लिंक-टाइम पर पॉइंटर चर का पता दिया जाता है। ऊपर आपके उदाहरण कोड में, जो किसी SIGSEGV को क्रैश या उत्पन्न करने की गारंटी है।

पवित्रता के लिए, हमेशा NULL को पॉइंटर्स इनिशियलाइज़ करें, इस तरह से अगर कोई बिना इसके डीरेलमेंट करने का प्रयास करता है mallocया newप्रोग्रामर को इस कारण से क्लू देगा कि प्रोग्राम गलत व्यवहार क्यों करता है।

आशा है कि यह मदद करता है और समझ में आता है,

Answer 12

ठीक है, अगर C ++ ने पॉइंटर्स को इनिशियलाइज़ किया है, तो C C की तुलना में "C ++ धीमा है" शिकायत करने वाले लोगों को लटकने के लिए कुछ वास्तविक होगा;)

Comments

वह मेरा कारण नहीं है। मेरा कारण यह है कि यदि हार्डवेयर में ROM के 512 बाइट और RAM के 128 बाइट हैं और पॉइंटर को शून्य करने का एक अतिरिक्त निर्देश यहां तक ​​कि एक बाइट भी है जो पूरे कार्यक्रम का एक बड़ा प्रतिशत है। मुझे वो बाइट चाहिए!

— जेरी जेरेमिया

Answer 13

C ++ एक C बैकग्राउंड से आता है - और इसके पीछे से आने वाले कुछ कारण हैं:

C, C ++ से भी अधिक एक विधानसभा भाषा प्रतिस्थापन है। यह कुछ भी नहीं करता है जो आप इसे करने के लिए नहीं कहते हैं। वहाँ: यदि आप इसे पूरा करना चाहते हैं - यह करो!

इसके अलावा, यदि आप नंगे धातु की भाषा में सी जैसी चीजों को शून्य करते हैं, तो स्वचालित रूप से निरंतरता सवाल उठाती है: यदि आप कुछ करते हैं - तो क्या यह स्वचालित रूप से शून्य होना चाहिए? स्टैक पर बनाई गई संरचना के बारे में क्या? सभी बाइट्स शून्य होना चाहिए? वैश्विक चर के बारे में क्या? "(0x18) जैसे कथन के बारे में क्या?" क्या इसका मतलब यह नहीं है कि स्मृति की स्थिति 0x18 शून्य होनी चाहिए?

Comments

दरअसल, सी में, यदि आप ऑल-जीरो मेमोरी आवंटित करना चाहते हैं, जिसका आप उपयोग कर सकते हैं calloc()।

— डेविड थॉर्नले

बस मेरी बात - यदि आप इसे करना चाहते हैं, तो आप कर सकते हैं, लेकिन यह आपके लिए

— स्वचालित रूप

Answer 14

आप किस बिंदु पर बात कर रहे हैं?

अपवाद सुरक्षा के लिए, हमेशा उपयोग auto_ptr, shared_ptr, weak_ptrऔर उनके अन्य वेरिएंट।
अच्छे कोड की एक बानगी वह है जिसमें एक भी कॉल शामिल नहीं है delete।

Comments

सी ++ 11 के बाद से, दूर auto_ptrऔर स्थानापन्न unique_ptr।

— डेडुप्लिकेटर

Answer 15

ओह यार। असली जवाब यह है कि मेमोरी को शून्य करना आसान है, जो कि पॉइंटर कहने के लिए बुनियादी आरंभ है। जिसका वस्तु से आरंभ करने से भी कोई लेना-देना नहीं है।

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

Comments

सूचक नहीं है, तो उम्मीद होने के लिए NULL, कि करने के लिए इसे आरंभ बस के रूप में ज्यादा एक त्रुटि है।

— Deduplicator