सी ++ स्ट्रिंग आवंटन

Question

क्या मुझे स्मृति आवंटन, स्कोप और सी ++ "स्ट्रिंग" ऑब्जेक्ट के बारे में हटाने की आवश्यकता है?

उदाहरण के लिए

:

#include <string> 

const char* func1() { 
    const char* s = "this is a literal string"; 
    return s; 
} 

string func2() { 
    std::string s = "this is a literal string"; 
    return s; 
} 

const char* func3() { 
    std::string s = "this is a literal string"; 
    return s.c_str(); 
} 

void func() { 
    const char* s1 = func1(); 
    std::string s2 = func2(); 
    const char* s3 = func3(); 

    delete s1; //? 
    delete s3; //? 
} 

func2: मैं s2 'नष्ट' की जरूरत नहीं है। func3: क्या मुझे 's3 को हटाने' की आवश्यकता है?

बीटीडब्ल्यू, func1 सही है? क्या func1 गुंजाइश छोड़ने के बाद वर्ण स्मृति सामग्री अभी भी उपलब्ध है? यदि हां, तो क्या मुझे इसे हटा देना चाहिए जब मुझे इसकी आवश्यकता नहीं है?

Answer 1

• func1() एक स्ट्रिंग शाब्दिक के लिए सूचक देता है। आपको स्ट्रिंग अक्षर को हटाना नहीं चाहिए।
• func2() (संभवतः, आपने std:: उपसर्ग छोड़ा) std::string देता है। यह खुद का ख्याल रखता है।
• func3() एक स्ट्रिंग पर एक सूचक लौटाता है जिसे std::string ऑब्जेक्ट द्वारा प्रबंधित किया जाता है जो फ़ंक्शन से बाहर निकलने पर नष्ट हो जाता है। फ़ंक्शन रिटर्न के बाद आपको उस पॉइंटर को स्पर्श नहीं करना चाहिए।

• आप स्मृति इस समारोह से वापस लौटे का ख्याल रखना होगा:

  const char* func4() { 
      char* s = new char[100]; 
      // fill char array with a string 
      return s; 
  } 
  

हालांकि, मैन्युअल संसाधन प्रबंधन मुश्किल है। स्टार्टर्स के लिए, यदि कोई फ़ंक्शन नग्न पॉइंटर लौटाता है, तो आप नहीं जानते कि यह एक ऑब्जेक्ट (char) या उसके सरणी को इंगित करता है और क्या आपको इसे हटाने की आवश्यकता है या नहीं। आपको उन सभी से बचना चाहिए और बस std::string पर चिपके रहें।

Answer 2

आपके पास s3 के साथ एक अलग समस्या है, अर्थात् फ़ंक्शन func3() फ़ंक्शन को लौटने पर किसी ऑब्जेक्ट में पॉइंटर देता है जो फ़ंक्शन लौटाता है। मत करो।

को स्पष्ट करने के लिए: Func3() के भीतर आपकी स्थानीय स्ट्रिंग ऑब्जेक्ट फ़ंक्शन की वापसी पर मौजूद रहेगी, इसलिए हटाने की कोई आवश्यकता नहीं है। हालांकि, आपके पास अभी भी अपने आंतरिक बफर के लिए एक सूचक है, जो आप वापस आते हैं। आप इसका उपयोग नहीं कर सकते।

बहुत अच्छा और विस्तृत अतीत जवाब यहाँ, ऐसा न हो कि अधिक भ्रम की स्थिति ensues: Is it more efficient to return a const reference

Answer 3

मैं प्रत्येक कार्य और उसके द्वारा दिया गया मान के उपचार के लिए प्रासंगिक कोड कटाव, और नीचे टिप्पणी:

const char* func1() { 
    const char* s = "this is a literal string"; 
    return s; 
} 
const char* s1 = func1(); 
delete s1; //? 

आप s1 हटा नहीं सकते, स्ट्रिंग के रूप में यह बताते हैं ढेर पर नहीं रहते है।

string func2() { 
    string s = "this is a literal string"; 
    return s; 
} 
string s2 = func2(); 

यह ठीक है। func2 का s गुंजाइश से बाहर हो गया है और साफ हो गया है। s2s से स्ट्रिंग को डुप्लिकेट करेगा, और func के अंत में स्वयं को साफ़ कर देगा।

const char* func3() { 
    string s = "this is a literal string"; 
    return s.c_str(); 
} 
const char* s3 = func3(); 
delete s3; //? 

func3 एक स्ट्रिंग है मुक्त कर दिया गया है एक सूचक देता है। delete s3 के निष्पादन पर आपको एक डबल फ्री अपवाद मिलेगा।

Answer 4

func3 में आपका स्ट्रिंग लोकल कंपाइलर द्वारा अंतर्निहित कन्स्ट्रक्टर string(const char*) को स्ट्रिंग शाब्दिक की एक प्रति के साथ अपने आंतरिक बफर को प्रारंभ करने के द्वारा बनाया गया है। फिर आप स्ट्रिंग के आंतरिक बफर में एक पॉइंटर वापस लौटते हैं जो तुरंत गुंजाइश से बाहर हो जाता है और जैसे ही फ़ंक्शन लौटाता है, मुक्त हो जाता है।