सी ++ स्ट्रिंग है जो शून्य हो सकता है

Question

मैं अपने C++ अनुप्रयोग में इस तरह स्ट्रिंग के आसपास पारित करने के लिए प्रयोग किया जाता है:

void baz() 
{ 
    foo("stackoverflow"); 
    foo(NULL); // very bad with foo implementation above 
} 

:

void foo(const std::string& input) 
{ 
    std::cout << input.size() << std::endl; 
} 

void bar() 
{ 
    foo("stackoverflow"); 
} 

अब मैं एक मामले में जहां मैं स्ट्रिंग शून्य होना चाहते है

मैं करने के लिए foo को बदल सकता है:

void foo(const std::string* input) 
{ 
    // TODO: support NULL input 
    std::cout << input->size() << std::endl; 
} 

लेकिन एक स्ट्रिंग शाब्दिक पारित करने के लिए या एककॉपी foo की कि कार्यान्वयन के लिए 0 मैं कुछ इस तरह लिखने की ज़रूरत:

void bar() 
{ 
    string input("hi"); // annoying temporary 
    foo(&input); 
    foo(NULL); // will work as long as foo handles NULL properly 
} 

मैं std::string से इनहेरिट और एक null संपत्ति जोड़ने के बारे में सोचना शुरू कर दिया है, लेकिन मैं इतना यकीन है कि यह एक अच्छा विचार है नहीं कर रहा हूँ। हो सकता है कि पैरामीटर के लिए const char* स्ट्रिंग का उपयोग करना बेहतर हो जो कि नल हो सकता है, लेकिन अगर मैं स्ट्रिंग (या न्यूल) की एक प्रति सहेजने के बिना अपनी याददाश्त को सहेजना चाहता हूं तो क्या होगा? (What are some of the drawbacks to using C-style strings? आदि देखें)

आसपास के किसी भी चालाक समाधान?

Answer 1

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

वैकल्पिक रूप से, बूस्ट :: वैकल्पिक का उपयोग करें, जो "यह चर निर्दिष्ट कर सकता है या नहीं हो सकता है" निर्दिष्ट करने के लिए एक और प्रकार-सुरक्षित तरीका की अनुमति देता है।

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

Answer 2

क्या होगा अगर तुम सिर्फ का उपयोग करें:

void foo(const char *xinput) 
{ 
    if (xinput == NULL) { 
     // do something exceptional with this 
     return; 
    } 
    std::string input(xinput); 
    // remainder of code as usual 
} 

हाँ, यह एक अतिरिक्त आवंटन और प्रतिलिपि उठाना होता है, और कार्यप्रणाली को कॉल में थोड़ा और अधिक वर्बोज़ है, क्योंकि आप हमेशा की तरह मामले में .c_str() उपयोग करने की आवश्यकता है, लेकिन यह आपको वह अर्थशास्त्र देता है जो आप चाहते हैं।

Answer 3

व्यक्तिगत रूप से, मैं अर्थ विज्ञान बदल शून्य के बजाय चारों ओर खाली std :: तार पारित करने के लिए होगा:

void foo(const std::string& input) 
{ 
    if (!input.empty()) 
     std::cout << input.size() << std::endl; 
} 

void bar() 
{ 
     foo(""); 
} 

Answer 4

आप फ़ंक्शन को अधिभार क्यों नहीं देते हैं और दूसरा अधिभार कोई तर्क नहीं देते हैं? फिर दोनों अधिभार आंतरिक रूप से एक फ़ंक्शन को कॉल कर सकते हैं जो पढ़ने के तर्क प्रदान करता है और वह स्वयं, std::string पर एक सूचक पारित हो जाता है।

void foo_impl(string const* pstr) { … } 

void foo(string const& str) { 
    foo_impl(&str); 
} 

void foo() { 
    foo_impl(0); 
} 

Answer 5

समारोह बचाव के लिए अधिक भार ...

void foo(const std::string& input) 
{ 
    std::cout << input << std::endl; 

    // do more things ... 
} 

void foo(const char* input) 
{ 
    if (input != NULL) foo(std::string(input)); 
} 

यह दोनों ग शैली चार सरणियों और std :: तार को स्वीकार करेंगे, और ढेर पर अतिरिक्त भूमि के ऊपर उठाना यदि आप एक में पारित करेंगे स्ट्रिंग शाब्दिक या चार सरणी, लेकिन आपको एक ही स्थान पर अपना कार्यान्वयन रखने और अपने अच्छे वाक्यविन्यास को रखने की अनुमति देता है।

Answer 6

या, दो पिछले जवाब का एक सा मिश्रण:

void fooImpl(const char* input) 
{ 
    if (input != NULL) 
     std::cout << input << std::endl; 
} 

void foo(const std::string& input) 
{ 
    fooImpl(input.c_str());  
} 

void foo(const char* input) 
{ 
    fooImpl(input); 
} 

एक ही इंटरफ़ेस, स्टैक पर कोई प्रति नहीं। यदि आप पसंद करते हैं, तो आप इनलाइन fooImpl भी इनलाइन कर सकते हैं।

Answer 7

बिल्कुल std::string से प्राप्त नहीं है। विरासत सी ++ में आपके पास सबसे सख्त युग्मन है, और आप केवल शून्यता की तलाश कर रहे हैं, जिसे आप वास्तव में const char*, अधिभार, या बस std::string * के साथ प्राप्त कर सकते हैं यदि आप वास्तव में चाहते हैं।