दिलचस्प पोस्ट
एंड्रॉइड: एस्केनेक्टस्क को अलग-अलग क्लास फाइल से कैसे चलाया जाता है? PHP एक्सएमएल को JSON कन्वर्ट स्क्रिप्ट टैग पर ओनलोड इवेंट को आग लगाने की कोशिश कर रहा है एक मोनद क्या है? मैं mysql में कैस्केड को कैसे हटाऊं? विंडोज स्टोर के लिए .NET पर FileStream कहां है? अनुप्रयोग के बीच अंतर क्या है। थ्रेड अपेशन और AppDomain.CurrentDomain.UnhandledException? रियायती WCF सेवा में ".svc" एक्सटेंशन को कैसे निकालें? सीएसएस में कोई ऊँचाई सेट नहीं होने के साथ div की ऊंचाई प्राप्त करें एसोसिएशन टेबल में अतिरिक्त फ़ील्ड के साथ पहले, बहुत से कई कोड बनाएं क्या नेस्टेड लेनदेन MySQL में अनुमत हैं? एक PHP से एक चर को पास करने में दूसरे को शामिल करें: वैश्विक बनाम नहीं नोड- http-proxy के साथ vhosts का उपयोग कैसे करें? HTML तालिका में JSON डेटा प्रदर्शित करें सी # में किसी अन्य विंडो पर फ़ॉर्म विंडो अटैच करें

एक निरर्थक स्ट्रिंग क्या है?

यह std :: string से कैसे भिन्न है?

Solutions Collecting From Web of "एक निरर्थक स्ट्रिंग क्या है?"

एक निरर्थक स्ट्रिंग वर्णों का एक निकटतम अनुक्रम है, जिनमें से अंतिम में बाइनरी बिट पैटर्न सभी शून्य हैं। मुझे यकीन नहीं है कि आप एक "सामान्य स्ट्रिंग" से क्या कह रहे हैं, लेकिन यदि आप std::string , तो एक std::string की आवश्यकता नहीं है ( जब तक C + + 11 ) जुड़ा हो, और इसकी आवश्यकता नहीं है एक टर्मिनेटर इसके अलावा, एक std::string स्ट्रिंग डेटा को हमेशा std::string ऑब्जेक्ट द्वारा आवंटित और प्रबंधित किया जाता है जो इसे शामिल करता है; एक निरर्थक स्ट्रिंग के लिए, ऐसा कोई कंटेनर नहीं है, और आप आमतौर पर बेअर पॉइंटर्स का उपयोग करके इस तरह के स्ट्रिंग को देखें और प्रबंधित करते हैं।

ये सब वास्तव में किसी भी सभ्य C ++ पाठ्य पुस्तक में शामिल होना चाहिए – मैं त्वरित सी ++ को प्राप्त करने की सलाह देता हूं, उनमें से सबसे अच्छे में से एक

एक "स्ट्रिंग" वास्तव में सिर्फ char एस की एक सरणी है; एक निरर्थक स्ट्रिंग एक है जहां एक रिक्त वर्ण '\0' स्ट्रिंग के अंत को चिह्नित करता है (जरूरी नहीं कि सरणी के अंत)। कोड में सभी तार (दोहरे उद्धरण "" द्वारा सीमांकित) स्वचालित रूप से कंपाइलर द्वारा रिक्त समाप्त हो गए हैं।

तो उदाहरण के लिए, "hi" {'h', 'i', '\0'}

स्ट्रिंग का प्रतिनिधित्व करने के दो मुख्य तरीके हैं:

1) अंत में एएससीआईआई अशक्त (शून्य) चरित्र, 0 के साथ वर्णों का एक क्रम। आप टर्मिनेटर के लिए खोज कर कितनी देर तक बता सकते हैं। इसे एक निरर्थक स्ट्रिंग कहा जाता है, या कभी-कभी नल-समाप्त होता है

2) अक्षरों का एक क्रम, प्लस एक अलग फ़ील्ड (या तो एक पूर्णांक लंबाई, या स्ट्रिंग के अंत में एक सूचक), यह बताए कि यह कितनी देर है।

मुझे "सामान्य स्ट्रिंग" के बारे में निश्चित नहीं है, लेकिन अक्सर क्या होता है कि जब किसी विशेष भाषा के बारे में बात करते हैं, तो शब्द "स्ट्रिंग" का अर्थ उस भाषा के मानक प्रतिनिधित्व के लिए किया जाता है। तो जावा में, java.lang.String एक प्रकार 2 स्ट्रिंग है, इसलिए कि "स्ट्रिंग" का मतलब है। सी में, "स्ट्रिंग" का अर्थ शायद एक प्रकार 1 स्ट्रिंग है। मानक सटीक होना काफी स्पष्ट है, लेकिन लोग हमेशा "स्पष्ट" क्या छोड़ना चाहते हैं।

सी ++ में, दुर्भाग्य से, दोनों प्रकार मानक होते हैं। std :: string एक प्रकार 2 स्ट्रिंग है [*], लेकिन मानक पुस्तकालय कार्य सी से प्राप्त विरासत प्रकार 1 पर कार्य करते हैं।

[*] असल में, std :: स्ट्रिंग अक्सर वर्णों की एक सरणी के रूप में लागू होती है, एक अलग लंबाई क्षेत्र और एक नूल टर्मिनेटर के साथ। ऐसा इसलिए है कि c_str() फ़ंक्शन को कभी भी स्ट्रिंग डेटा की प्रतिलिपि बनाने या पुन: आवंटित करने की आवश्यकता के बिना कार्यान्वित किया जा सकता है। मुझे याद नहीं हो सकता है कि यह लंबाई के बिना भंडारण के बिना std :: स्ट्रिंग लागू करने के लिए कानूनी है या नहीं: सवाल यह है कि मानक द्वारा जटिलता गारंटी की आवश्यकता क्यों है। सामान्य size() के कंटेनरों के लिए size() ओ (1) होने की सिफारिश की जाती है, लेकिन वास्तव में यह होना जरूरी नहीं है तो यहां तक ​​कि अगर यह कानूनी है, तो std :: स्ट्रिंग का कार्यान्वयन जो केवल न्यूल टर्मिनेटर का उपयोग करता है, आश्चर्यजनक होगा।

 '\0' 

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

यह स्ट्रिंग को केवल एक बाइट के ओवरहेड के साथ किसी भी लम्बाई की अनुमति देता है; गिनती को संचय करने का विकल्प या तो एक स्ट्रिंग की लंबाई सीमा 255 या एक से अधिक बाइट के ओवरहेड की आवश्यकता है।

विकिपीडिया से

सी ++ std::string इस दूसरे सम्मेलन का अनुसरण करता है और इसके डेटा को _Rep नामक एक संरचना द्वारा _Rep जाता है:

 // _Rep: string representation // Invariants: // 1. String really contains _M_length + 1 characters: due to 21.3.4 // must be kept null-terminated. // 2. _M_capacity >= _M_length // Allocated memory is always (_M_capacity + 1) * sizeof(_CharT). // 3. _M_refcount has three states: // -1: leaked, one reference, no ref-copies allowed, non-const. // 0: one reference, non-const. // n>0: n + 1 references, operations require a lock, const. // 4. All fields==0 is an empty string, given the extra storage // beyond-the-end for a null terminator; thus, the shared // empty string representation needs no constructor. struct _Rep_base { size_type _M_length; size_type _M_capacity; _Atomic_word _M_refcount; }; struct _Rep : _Rep_base { // Types: typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc; // (Public) Data members: // The maximum number of individual char_type elements of an // individual string is determined by _S_max_size. This is the // value that will be returned by max_size(). (Whereas npos // is the maximum number of bytes the allocator can allocate.) // If one was to divvy up the theoretical largest size string, // with a terminating character and m _CharT elements, it'd // look like this: // npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT) // Solving for m: // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1 // In addition, this implementation quarters this amount. static const size_type _S_max_size; static const _CharT _S_terminal; // The following storage is init'd to 0 by the linker, resulting // (carefully) in an empty string with one reference. static size_type _S_empty_rep_storage[]; static _Rep& _S_empty_rep() { // NB: Mild hack to avoid strict-aliasing warnings. Note that // _S_empty_rep_storage is never modified and the punning should // be reasonably safe in this case. void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage); return *reinterpret_cast<_Rep*>(__p); } bool _M_is_leaked() const { return this->_M_refcount < 0; } bool _M_is_shared() const { return this->_M_refcount > 0; } void _M_set_leaked() { this->_M_refcount = -1; } void _M_set_sharable() { this->_M_refcount = 0; } void _M_set_length_and_sharable(size_type __n) { #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING if (__builtin_expect(this != &_S_empty_rep(), false)) #endif { this->_M_set_sharable(); // One reference. this->_M_length = __n; traits_type::assign(this->_M_refdata()[__n], _S_terminal); // grrr. (per 21.3.4) // You cannot leave those LWG people alone for a second. } } _CharT* _M_refdata() throw() { return reinterpret_cast<_CharT*>(this + 1); } _CharT* _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2) { return (!_M_is_leaked() && __alloc1 == __alloc2) ? _M_refcopy() : _M_clone(__alloc1); } // Create & Destroy static _Rep* _S_create(size_type, size_type, const _Alloc&); void _M_dispose(const _Alloc& __a) { #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING if (__builtin_expect(this != &_S_empty_rep(), false)) #endif if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0) _M_destroy(__a); } // XXX MT void _M_destroy(const _Alloc&) throw(); _CharT* _M_refcopy() throw() { #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING if (__builtin_expect(this != &_S_empty_rep(), false)) #endif __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1); return _M_refdata(); } // XXX MT _CharT* _M_clone(const _Alloc&, size_type __res = 0); }; 

वास्तविक डेटा यहां से प्राप्त की जा सकती है:

 _Rep* _M_rep() const { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); } 

यह कोड स्निपेट, फ़ाइल basic_string.h से आता है जो मेरी मशीन पर स्थित है usr/include/c++/4.4/bits/basic_string.h

जैसे कि आप देख सकते हैं, अंतर महत्वपूर्ण है

एक निरर्थक स्ट्रिंग का अर्थ है कि आपकी स्ट्रिंग का अंत एक अशक्त-चार (सभी बिट शून्य) की घटना के माध्यम से परिभाषित किया गया है।

"अन्य स्ट्रिंग्स" जैसे कि अपनी खुद की लंबाई स्टोर करना है

एक निरर्थक स्ट्रिंग सी स्ट्रिंग लीटरल में एक मूल स्ट्रिंग फ़ॉर्मेट है, उदाहरण के लिए, शून्य-समाप्त होने के रूप में कार्यान्वित किया जाता है नतीजतन, पूरे कोड (सी रन-टाइम लाइब्रेरी के साथ शुरू करने के लिए) मानता है कि तार शून्य-समाप्त हो चुके हैं

एक निरर्थक समाप्त स्ट्रिंग (सी-स्ट्रिंग) चारों की एक सरणी है, और 0x0 मान वाले सरणी का अंतिम तत्व। Std :: string अनिवार्य रूप से एक वेक्टर है, जिसमें यह मूल्यों के लिए एक ऑटो-रिसाइज कंटेनर है। इसे एक अशक्त टर्मिनेटर की आवश्यकता नहीं है क्योंकि इसका आकार बदलने के लिए आवश्यक होने पर पता होना चाहिए।

ईमानदारी से, मैं std वाले सी-स्ट्रिंग को पसंद करता हूं, उनके पास बुनियादी पुस्तकालयों में अधिक अनुप्रयोग हैं, न्यूनतम कोड और आवंटन वाले लोग, और इसका उपयोग करने के लिए कड़ी मेहनत