सी आरंभ होने

Question

वस्तु ++ मैं एक सी प्रोग्रामर सी को समझने के लिए ++ की कोशिश कर रहा हूँ।

Dog* sparky = new Dog(); 

जिसका मतलब है कि अगर बाद में आप क्या करेंगे:

delete sparky; 

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

Dog sparky; 

के बजाय ऊपर का उपयोग करें और नाशक दायरे से बाहर चला जाता है एक बार स्पार्की कहा जा जाने के लिए किसी भी कारण है?

धन्यवाद!

Answer 1

पर इसके विपरीत, आप हमेशा हद तक ढेर चाहिए पसंद करते आवंटन, कि एक सामान्य नियम के रूप में, आप नए कभी नहीं होना चाहिए/अपने उपयोगकर्ता कोड में हटा दें।

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

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

इस मुहावरे के लिए सबसे आम नाम RAII

इसके अलावा स्मार्ट सूचक वर्ग है जो जब आप एक समर्पित आरए II वस्तु के बाहर नए के साथ कुछ आवंटित करने के लिए क्या है दुर्लभ मामलों पर जिसके परिणामस्वरूप संकेत रैप करने के लिए उपयोग किया जाता है पर गौर है। इसके बजाय आप पॉइंटर को एक स्मार्ट पॉइंटर पर पास करते हैं, जो उसके जीवनकाल को ट्रैक करता है, उदाहरण के लिए संदर्भ गिनती के द्वारा, और आखिरी संदर्भ दायरे से बाहर होने पर विनाशक को बुलाता है।मानक पुस्तकालय में std::unique_ptr सरल स्कोप-आधारित प्रबंधन के लिए है, और std::shared_ptr जो साझा स्वामित्व को लागू करने के लिए संदर्भ गणना करता है।

कई ट्यूटोरियल जैसे ...

तो क्या आपको पता चला है कि ज्यादातर ट्यूटोरियल चूसना है एक टुकड़ा का उपयोग कर वस्तु इन्स्टेन्शियशन का प्रदर्शन। ;) अधिकतर ट्यूटोरियल आपको लुसी सी ++ प्रथाओं को सिखाते हैं, जिसमें आवश्यकतानुसार चर बनाने के लिए नए/डिलीट को कॉल करना शामिल है, और आपको अपने आवंटन के जीवनकाल को ट्रैक करने में कठिनाई होती है।

Answer 2

ठीक है, सूचक का उपयोग करने का कारण बिल्कुल वही होगा जो malloc के साथ आवंटित सी में पॉइंटर्स का उपयोग करने का कारण होगा: यदि आप चाहते हैं कि आपकी ऑब्जेक्ट आपके चर से अधिक लाइव रहें!

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

Answer 3

एकमात्र कारण मैं के बारे में चिंता चाहते हैं कि कुत्ता अब, ढेर पर आवंटित किया जाता है ना कि स्टेक से है। तो अगर कुत्ता आकार मेगाबाइट है, तो आप एक समस्या हो सकती है,

आप नए जाना, मार्ग को नष्ट/अपवाद से सावधान रहना आवश्यकता है तो। और इसके कारण आपको ऑब्जेक्ट आजीवन प्रबंधन के लिए auto_ptr या बूस्ट स्मार्ट पॉइंटर प्रकारों में से एक का उपयोग करना चाहिए।

Answer 4

नई करने का कोई कारण (ढेर पर) जब आप ढेर पर आवंटित कर सकते हैं (जब तक कि किसी कारण से आप एक छोटे से ढेर हो गया और ढेर का उपयोग करना चाहते कर दिया है।

आप प्रयोग करने पर विचार करना चाह सकते हैं यदि आप ढेर पर आवंटित करना चाहते हैं तो एक मानक_ptr (या इसके रूपों में से एक)। यदि आपके द्वारा साझा_प्टर के सभी संदर्भ अस्तित्व से बाहर हो गए हैं तो यह आपके लिए हटाएगा।

Answer 5

एक बहुत ही महत्वपूर्ण अचल संपत्ति के रूप में ढेर का इलाज करें और इसे बहुत ही समझदारी से उपयोग करें। मूल अंगूठे नियम स्टैक का उपयोग करना संभव है जब भी संभव हो और जब भी कोई अन्य तरीका न हो तो ढेर का उपयोग करें। स्टैक पर ऑब्जेक्ट्स आवंटित करके आप कई लाभ प्राप्त कर सकते हैं जैसे:

(1)। अपवाद

(2) के मामले में आपको अवांछित स्टैक के बारे में चिंता करने की आवश्यकता नहीं है। आपको अपने हीप मैनेजर द्वारा आवश्यक स्थान से अधिक स्थान आवंटित करने के कारण स्मृति विखंडन के बारे में चिंता करने की आवश्यकता नहीं है।

Answer 6

मैंने उन लोगों से इस विरोधी पैटर्न को देखा है जो पता-ऑपरेटर के पते को नहीं मिला है। अगर उन्हें एक पॉइंटर के साथ एक फ़ंक्शन कॉल करने की आवश्यकता है, तो वे हमेशा ढेर पर आवंटित करेंगे ताकि उन्हें पॉइंटर मिल सके।

void FeedTheDog(Dog* hungryDog); 

Dog* badDog = new Dog; 
FeedTheDog(badDog); 
delete badDog; 

Dog goodDog; 
FeedTheDog(&goodDog); 

Answer 7

मुझे विजुअल स्टूडियो में एक ही समस्या थी। आपको इसका उपयोग करना होगा:

yourClass-> classMethod();

बजाय:

yourClass.classMethod();

Answer 8

एक अतिरिक्त कारण है, जिसने किसी और का उल्लेख नहीं किया है, आप अपनी वस्तु को गतिशील रूप से क्यों चुन सकते हैं। गतिशील, ढेर आधारित वस्तुएं आपको polymorphism का उपयोग करने की अनुमति देती हैं।

Answer 9

हालांकि स्टैक पर चीजें रखने से आवंटन और स्वत: मुक्त करने वाली चीजों के मामले में इसका लाभ हो सकता है, इसके कुछ नुकसान हैं।

1. आप ढेर पर भारी वस्तुओं आवंटित करने के लिए नहीं चाहते हो सकता है।

2. रनटाइम प्रकार! इस कोड पर विचार करें:

#include <iostream> 

class A { 
public: 
    virtual void f(); 
}; 

class B : public A { 
public: 
    virtual void f(); 
}; 

void A::f() {cout << "A\n";} 
void B::f() {cout << "B\n";} 

int main(void) { 
    A *a = new B(); 
    a->f(); 
    delete a; 
    return 0; 
} 

यह स्पष्ट रूप से प्रिंट होगा "बी \ n"। अब देखते हैं जब ढेर का उपयोग कर क्या होता है की सुविधा देता है:

int main(void) { 
    A a = B(); 
    a->f(); 
    return 0; 
} 

यह होगा प्रिंट "एक \ n" (सी ++ लोग obviosly के लिए)। और यह उन लोगों के लिए सहज नहीं हो सकता है जो जावा या अन्य ओओपी शैली भाषाओं के साथ समान हैं। कारण यह है कि आपके पास बी के उदाहरण पर कोई सूचक नहीं है। लेकिन बी का एक उदाहरण बनाया गया है और फिर ए के एक उदाहरण में कॉपी किया गया है (जो कि पूरी तरह से नव निर्मित है)।

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