C ++ में s के सरणियों को प्रबंधित std::stringकरने के char*लिए मुझे कब उपयोग करना चाहिए और कब करना चाहिए char?
ऐसा लगता है कि आपको उपयोग करना चाहिए char*अगर प्रदर्शन (गति) महत्वपूर्ण है और आप स्मृति प्रबंधन के कारण कुछ जोखिम भरा व्यवसाय स्वीकार करने के लिए तैयार हैं।
क्या विचार करने के लिए अन्य परिदृश्य हैं?
जवाबों:
यदि आप प्रतिलिपि से बचने के लिए बड़े हैं, या उदाहरण के लिए एक पॉइंटर, तो आप संदर्भ द्वारा std :: strings पास कर सकते हैं, इसलिए मुझे char संकेत का उपयोग करके कोई वास्तविक लाभ दिखाई नहीं देता है।
मैं std :: string / wstring का उपयोग कमोबेश हर चीज के लिए करता हूं जो वास्तविक टेक्स्ट है। char *हालांकि अन्य प्रकार के डेटा के लिए उपयोगी है और आप यह सुनिश्चित कर सकते हैं कि इसे वैसे ही निपटाया जाए जैसे यह होना चाहिए। अन्यथा std :: वेक्टर जाने का रास्ता है।
इस सब के लिए शायद अपवाद हैं।
char *लगभग कोई उपरि नहीं है। वास्तव में जो ओवरहेड std::stringमेरे पास नहीं है, वह कार्यान्वयन पर निर्भर होने की संभावना है। मैं शायद ही ओवरहेड को नंगे चार पॉइंटर की तुलना में बहुत अधिक होने की उम्मीद करता हूं। चूंकि मैं मानक की एक प्रति का स्वामी नहीं हूं, मैं वास्तव में मानक द्वारा की गई किसी भी गारंटी का विस्तार नहीं कर सकता। किए जाने वाले संचालन के आधार पर किसी भी प्रदर्शन अंतर में भिन्नता होगी। std::string::sizeचरित्र डेटा के बगल में आकार संग्रहीत कर सकता है और इस प्रकार से अधिक तेज़ हो सकता है strlen।
append(const string&)और append(const char*, size_t)इसके बजाय operator+=()।
मेरा नज़रिया है:
हां, कभी-कभी आप वास्तव में ऐसा कर सकते हैं। कास्ट चार * का उपयोग करते समय, स्टैक और स्ट्रिंग शाब्दिक पर आवंटित चार सरणियाँ आप इसे इस तरह से कर सकते हैं कि कोई स्मृति आवंटन नहीं है।
इस तरह के कोड को लिखने के लिए अक्सर स्ट्रिंग या वेक्टर का उपयोग करने की तुलना में अधिक सोच और देखभाल की आवश्यकता होती है, लेकिन एक उचित तकनीकों के साथ यह किया जा सकता है। उचित तकनीकों के साथ कोड सुरक्षित हो सकता है, लेकिन आपको हमेशा यह सुनिश्चित करने की आवश्यकता होती है कि चार में नकल करते समय [] या तो आपके पास नकल की जा रही स्ट्रिंग की कुछ गारंटी है, या आप जांचते हैं और सुशोभित तार को सावधानी से संभालते हैं। ऐसा नहीं करने से क्या कार्य करने वाले परिवार को असुरक्षित होने की प्रतिष्ठा मिली।
चेर [] बफ़र सुरक्षा के लिए, टेम्पलेट मदद कर सकते हैं, क्योंकि वे आपके लिए बफर आकार को संभालने के लिए एक एनकैप्सुलेशन बना सकते हैं। इस तरह के टेम्प्लेट Microsoft द्वारा लागू किए जाते हैं जैसे कि strcpy के लिए सुरक्षित प्रतिस्थापन प्रदान करने के लिए। यहाँ उदाहरण मेरे अपने कोड से निकाला गया है, असली कोड में बहुत अधिक विधियाँ हैं, लेकिन मूल विचार को व्यक्त करने के लिए यह पर्याप्त होना चाहिए:
template <int Size>
class BString
{
char _data[Size];
public:
BString()
{
_data[0]=0;
// note: last character will always stay zero
// if not, overflow occurred
// all constructors should contain last element initialization
// so that it can be verified during destruction
_data[Size-1]=0;
}
const BString &operator = (const char *src)
{
strncpy(_data,src,Size-1);
return *this;
}
operator const char *() const {return _data;}
};
//! overloads that make conversion of C code easier
template <int Size>
inline const BString<Size> & strcpy(BString<Size> &dst, const char *src)
{
return dst = src;
}
char*तार हमेशा स्टैक पर नहीं होते हैं। char *str = (char*)malloc(1024); str[1024] = 0;
जब आप स्थैतिक स्ट्रिंग स्थिरांक की आवश्यकता होती है तो एक अवसर जिसका आप उपयोग करते हैं char*और नहीं std::stringकरते हैं। इसका कारण यह है कि आपके पास अपने स्थैतिक चर को इनिशियलाइज़ करने के लिए ऑर्डर मॉड्यूल पर कोई नियंत्रण नहीं होता है, और एक अलग मॉड्यूल से एक और वैश्विक ऑब्जेक्ट आपके स्ट्रिंग को संदर्भित कर सकता है, इससे पहले कि यह प्रारंभ हो जाए। http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Static_and_Global_Variables
std::string पेशेवरों:
std::stringविपक्ष: - दो अलग एसटीएल स्ट्रिंग उदाहरण एक ही अंतर्निहित बफर को साझा नहीं कर सकते हैं। इसलिए यदि आप मूल्य से गुजरते हैं तो आपको हमेशा एक नई प्रति मिलती है। - कुछ प्रदर्शन जुर्माना है, लेकिन मैं कहूंगा कि जब तक आपकी आवश्यकताएं विशेष नहीं हैं, यह नगण्य है।
आपको char*निम्नलिखित मामलों में उपयोग करने पर विचार करना चाहिए :
वास्तव में, C ++ में, char*अक्सर निश्चित छोटे शब्द के लिए उपयोग किया जाता है, विकल्प, फ़ाइल नाम, आदि के रूप में ...
C ++ std :: string का उपयोग कब करें:
चार का उपयोग कब करें *
यदि आप लाइब्रेरी लिख रहे हैं तो (const) char * को पैरामीटर के रूप में उपयोग करें। std :: स्ट्रिंग कार्यान्वयन अलग-अलग संकलक के बीच भिन्न होते हैं।
आप एक std :: string (जैसे जैसे find) पर अधिकांश ऑपरेशनों को यथासंभव अनुकूलित करने की अपेक्षा कर सकते हैं, इसलिए वे कम से कम और साथ ही एक शुद्ध C समकक्ष प्रदर्शन करने की संभावना रखते हैं।
यह भी ध्यान देने योग्य बात है कि std :: string iterators, अक्सर चार्ट में अंतर्निहित चार्ट में मैप करते हैं। तो किसी भी एल्गोरिथ्म जो आप पुनरावृत्तियों के शीर्ष पर है, अनिवार्य रूप से प्रदर्शन के मामले में चार के शीर्ष पर समान एल्गोरिथ्म के समान है।
देखने के लिए चीजें उदाहरण के लिए हैं operator[]- अधिकांश एसटीएल कार्यान्वयन सीमा की जाँच नहीं करते हैं, और इसे अंतर्निहित वर्ण सरणी पर उसी ऑपरेशन में अनुवाद करना चाहिए। AFAIK STLPort वैकल्पिक रूप से सीमा जाँच कर सकती है, जिस बिंदु पर यह ऑपरेटर थोड़ा धीमा होगा।
तो क्या करता है std :: string आपको फायदा करती है? यह आपको मैनुअल मेमोरी प्रबंधन से अनुपस्थित करता है; सरणी का आकार बदलना आसान हो जाता है, और आपको आम तौर पर मुक्त स्मृति के बारे में कम सोचना पड़ता है।
यदि आप स्ट्रिंग का आकार बदलते समय प्रदर्शन के बारे में चिंतित हैं, तो एक reserveफ़ंक्शन है जो आपको उपयोगी मिल सकता है।
अगर आप टेक्स्ट आदि जैसे वर्णों का उपयोग कर रहे हैं, तो std :: string का उपयोग अधिक लचीला और प्रयोग करने में आसान है। अगर आप इसका इस्तेमाल डाटा स्टोरेज जैसी किसी और चीज के लिए करते हैं? सरणियों का उपयोग करें (वैक्टर को प्राथमिकता दें)
यहां तक कि जब प्रदर्शन महत्वपूर्ण होता है तो आप बेहतर उपयोग करते हैं vector<char>- यह अग्रिम (रिजर्व () विधि) में मेमोरी आवंटन की अनुमति देता है और आपको मेमोरी लीक से बचने में मदद करेगा। वेक्टर का उपयोग :: ऑपरेटर [] एक ओवरहेड की ओर जाता है, लेकिन आप हमेशा बफर के पते को निकाल सकते हैं और इसे ठीक उसी तरह अनुक्रमित कर सकते हैं जैसे कि यह एक चार * था।
AFAIK आंतरिक रूप से सबसे std :: स्ट्रिंग को कॉपी पर लिखें, संदर्भ को ओवरहेड से बचने के लिए शब्दार्थ गिना जाता है, भले ही तार संदर्भ से पारित न हों।