कैसे ठीक से वापस जाने के लिए std :: स्ट्रिंग (या कैसे ठीक है कि दिए गए मान का उपयोग करने)

Question

आप एक वर्ग है जो एक वैश्विक (जैसे एप्लिकेशन के क्रम के लिए उपलब्ध)

class MyClass { 
    protected: 
    std::string m_Value; 
    public: 
    MyClass() : m_Value("hello") {} 
    std::string value() { return m_Value; }  
}; 

MyClass v1; 

पहले का उपयोग करना है कहो प्रपत्र मुझे अजीब व्यवहार देता है जब मैं

printf("value: %s\n", v1.value().c_str()); 

कर ऐसा लगता है कि स्ट्रिंग के रूप में यद्यपि स्मृति से गायब हो जाता है printf से पहले इसका इस्तेमाल कर सकते हैं। कभी-कभी यह मूल्य प्रिंट करता है: हैलो अन्य बार यह क्रैश या प्रिंट नहीं करता है।

मैं पहली बार इतना

std::string copiedString = v1.value(); 
    printf("value: %s\n", copiedString.c_str()); 

चीजें काम करने की तरह स्ट्रिंग कॉपी करते हैं।

निश्चित रूप से अस्थायी स्ट्रिंग के साथ ऐसा करने से बचने का एक तरीका होना चाहिए।

संपादित करें: तो सर्वसम्मति एक कॉन्स std :: स्ट्रिंग & वापसी मूल्य के साथ जाना है।

मुझे पता है कि हर कोई कहता है कि मूल कोड ठीक होना चाहिए लेकिन मैं आपको बता सकता हूं कि मैंने विंडोज सीई पर एमएसवीसी 2005 को इसके साथ परेशानी है, लेकिन केवल सीई बॉक्स पर देखा है। Win32 क्रॉस संकलन नहीं है।

Answer 1

ठीक है, कोड के साथ कुछ भी गलत नहीं है (जैसा कि मैंने इसे समझा है)। यह इष्टतम नहीं है और निश्चित रूप से The Right Way (R) नहीं है, आपको अपने कोड को संशोधित करना चाहिए जैसे villentehaspam सुझाव। जैसा कि अब है, आपका कोड स्ट्रिंग m_value की प्रतिलिपि बनाता है क्योंकि आप मान द्वारा वापस आते हैं, जो केवल एक कॉन्स्ट संदर्भ लौटने के समान नहीं है।

यदि आप एक पूर्ण कोड नमूना प्रदान करते हैं जो समस्या दिखाता है, तो मैं आपकी मदद कर सकता हूं।

Answer 2

आपका कोड ठीक काम करना चाहिए। कुछ और गलत है, कि हम इस टेस्टकेस से नहीं पहचान सकते हैं। शायद स्मृति त्रुटियों की खोज के लिए valgrind के माध्यम से अपने निष्पादन योग्य चलाएं।

Answer 3

यह महत्वपूर्ण नहीं है कि उस वर्ग में std :: स्ट्रिंग रिटर्न एक कॉन्स का उपयोग कर सकता है और आप केवल सदस्य मूल्य की एक प्रति बना रहे हैं जो एक अपशिष्ट है।

std::string value() const { return m_value; } 

Answer 4

यहाँ आम तौर पर हो रहा है जब आप लिखते हैं:

printf("value: %s\n", v1.value().c_str()); 

1. संकलक v1.value() से दिए गए मान धारण करने के लिए एक अस्थायी std::string बनाता है।
2. यह v1.value() पर कॉल करता है और अस्थायी स्ट्रिंग में अपना रिटर्न मान डालता है (वास्तव में यह कैसे भिन्न हो सकता है: आमतौर पर यह अस्थायी के लिए विधि के छिपे पैरामीटर के रूप में संदर्भित करेगा। चर्चा के लिए http://en.wikipedia.org/wiki/Return_value_optimization देखें)।
3. यह अस्थायी std::string पर .c_str() पर कॉल करता है, यह const char * परिणाम कहीं दूर (उदाहरण के लिए एक रजिस्टर) को दबाता है।
4. अब यह अस्थायी std::string के साथ समाप्त हो गया है, इसलिए इसे नष्ट कर देता है (यानी इसके विनाशक को कॉल करता है, शायद कुछ स्टैक स्पेस को मुक्त कर सकता है)।
5. यह const char * पॉइंटर को printf() पर तर्क के रूप में चरण (3) में मिला है।

समस्या यह है कि स्मृति के लिए चरण 3 अंक में सूचक अस्थायी std::string द्वारा आवंटित है, जो जब के अस्थायी नाशक कहा जाता है मुक्त कर दिया जाता है। यह स्मृति printf() द्वारा उपयोग किए जाने तक लंबे समय तक चली जा सकती है।

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

std::string copiedString = v1.value(); 
printf("value: %s\n", copiedString.c_str()); 

क्योंकि copiedString के लिए नाशक तक copiedString दायरे से बाहर चला जाता है कहा जाता है नहीं होता है, printf() के कुछ समय बाद वापस आ गया है। वास्तव में, यह v1.value().c_str() से कम कुशल नहीं है, क्योंकि किसी भी मामले में अस्थायी std::string बनाया जाता है।

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