वर्ग और वस्तुएं
एक वर्ग चर और कार्यों का एक समूह है जो एक साथ काम करते हैं; जहां वेरिएबल के पास असाइन किए गए मान नहीं हैं। जब वेरिएबल्स को मान असाइन किए जाते हैं, तो क्लास एक ऑब्जेक्ट बन जाती है। एक ही वर्ग को दिए गए विभिन्न मूल्यों का परिणाम अलग-अलग वस्तुओं में होता है; यानी, अलग-अलग वस्तुएं अलग-अलग मूल्यों के साथ एक ही वर्ग हैं। कहा जाता है कि किसी क्लास से ऑब्जेक्ट बनाना ऑब्जेक्ट को इंस्टेंट करना है।
नाम, स्ट्रिंग, एक वर्ग है। स्ट्रिंग क्लास से बनाई गई ऑब्जेक्ट में एक प्रोग्रामर चुना हुआ नाम होता है।
क्लास से संबंधित एक फ़ंक्शन को क्लास से किसी ऑब्जेक्ट को इंस्टेंट करने की आवश्यकता होती है। सी ++ में, उस फ़ंक्शन का नाम वर्ग के नाम के समान होता है। प्रोग्रामर द्वारा कक्षा से बनाई गई (तत्काल) वस्तुओं को अलग-अलग नाम दिए गए हैं।
एक वर्ग से एक वस्तु बनाने का अर्थ है वस्तु का निर्माण करना; इसका अर्थ तत्काल करना भी है।
एक सी ++ प्रोग्राम जो स्ट्रिंग क्लास का उपयोग करता है, फ़ाइल के शीर्ष पर निम्न पंक्तियों से शुरू होता है:
#शामिल#शामिल
नेमस्पेस एसटीडी का उपयोग करना;
पहली पंक्ति इनपुट/आउटपुट के लिए है। दूसरी पंक्ति प्रोग्राम को स्ट्रिंग क्लास की सभी सुविधाओं का उपयोग करने की अनुमति देना है। तीसरी पंक्ति प्रोग्राम को मानक नामस्थान में नामों का उपयोग करने की अनुमति देती है।
किसी फ़ंक्शन को ओवरलोड करना
जब दो या दो से अधिक भिन्न फ़ंक्शन हस्ताक्षरों का एक ही नाम होता है, तो उस नाम को अतिभारित कहा जाता है। जब एक फ़ंक्शन को कॉल किया जाता है, तो संख्या और प्रकार के तर्क निर्धारित करते हैं कि कौन सा फ़ंक्शन निष्पादित किया गया है।
निर्माण
डोरी()
निम्नलिखित कथन बिना किसी वर्ण के शून्य लंबाई की एक स्ट्रिंग का निर्माण करता है।
यह वर्ग (ऑब्जेक्ट प्रकार), स्ट्रिंग के नाम से शुरू होता है। इसके बाद प्रोग्रामर द्वारा दिए गए ऑब्जेक्ट स्ट्रिंग का नाम आता है। असाइनमेंट ऑपरेटर निम्नानुसार है; फिर खाली कोष्ठक वाले कंस्ट्रक्टर का नाम। यहां, strCol सभी डेटा सदस्यों (गुणों) और सदस्य कार्यों (विधियों) के साथ तत्काल वस्तु है।
स्ट्रिंग (str)
यह उपरोक्त के समान है, लेकिन कंस्ट्रक्टर में या तो एक स्ट्रिंग अक्षर या एक पहचानकर्ता को एक तर्क के रूप में लेता है। निम्नलिखित कथन इसे दर्शाता है:
प्रारंभकर्ता सूची के साथ निर्माण
निम्नलिखित कोड इसे दिखाता है:
स्ट्रिंग strCol=डोरी({'मैं','','NS','या','वी','और','','तथा','या','यू',' 0'});स्ट्रिंग शाब्दिक है मैं तुमसे प्यार करता हूँ। प्रारंभकर्ता सूची के अंत में शून्य वर्ण नोट करें।
स्ट्रिंग (str, n)
यह किसी अन्य स्ट्रिंग के पहले n वर्णों का एक स्ट्रिंग संग्रह बनाता है। निम्नलिखित कोड इसे दिखाता है:
charपी[] = 'मैं तुमसे प्यार करता हूँ';स्ट्रिंग strCol=डोरी(पी, 6);
लागत<<strCol<< 'एन';
आउटपुट आई लव यू के पहले 6 पात्रों के साथ आई लव यू है। याद रखें: सिंगल स्पेस एक कैरेक्टर है।
स्ट्रिंग (str, स्थिति, n)
यह n वर्णों का एक स्ट्रिंग संग्रह बनाता है, जो किसी अन्य स्ट्रिंग के शून्य-आधारित अनुक्रमित स्थिति, pos से शुरू होता है। निम्नलिखित कोड इसे दिखाता है:
charपी[] = 'मैं तुमसे प्यार करता हूँ';स्ट्रिंग strCol=डोरी(पी, 2, 4);
लागत<<strCol<< 'एन';
आउटपुट है, प्यार।
उपरोक्त दो मामलों के लिए, यदि n स्ट्रिंग के आकार से बड़ा है, तो out_of_range अपवाद फेंक दिया जाता है - बाद में देखें।
स्ट्रिंग (एन, 'सी')
n वर्णों का एक संग्रह बनाता है, जहाँ सभी वर्ण समान होते हैं। विचार करना,
स्ट्रिंग strCol=डोरी(5,'और');लागत<<strCol<< 'एन';
आउटपुट है, ईईईईई, 5 ई।
एक स्ट्रिंग असाइन करना
दोनों तारों को घोषित करने के बाद, एक स्ट्रिंग को निम्नानुसार सौंपा जा सकता है:
स्ट्रिंग strCol1=डोरी('मैं तुमसे प्यार करता हूँ');स्ट्रिंग strCol2;
strCol2=strCol1;
लागत<<strCol2<< 'एन';
आउटपुट है, आई लव यू।
इटरेटर के साथ निर्माण
एक पुनरावर्तक संग्रह के मूल्यों के माध्यम से स्कैनिंग का एक सामान्य प्रतिनिधित्व प्रदान करता है। इटरेटर के साथ एक स्ट्रिंग बनाने के लिए एक सिंटैक्स है:
टेम्पलेट<क्लास इनपुटइटरेटर>बेसिक_स्ट्रिंग(इनपुटइटरेटर शुरू,इनपुटइटरेटर अंत, स्थिरांकसंभाजकऔर
प्रति=संभाजक());
यह श्रेणी के लिए एक स्ट्रिंग बनाता है [आरंभ, अंत) - विवरण बाद में देखें।
एक स्ट्रिंग को नष्ट करना
एक स्ट्रिंग को नष्ट करने के लिए, बस इसे दायरे से बाहर जाने दें।
स्ट्रिंग क्लास एलिमेंट एक्सेस
एक तत्काल स्ट्रिंग ऑब्जेक्ट को एक सरणी की तरह उप-स्क्रिप्टेड (अनुक्रमित) किया जा सकता है। सूचकांक की गिनती शून्य से शुरू होती है।
स्ट्रिंगनाम [i]
ऑपरेशन स्ट्रिंगनाम [i] i . पर वर्ण (तत्व) का संदर्भ देता हैवांचरित्र संग्रह का सूचकांक। निम्नलिखित कोड आउटपुट वी:
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');charचौधरी=strCol[4];
लागत<<चौधरी<< 'एन';
स्ट्रिंगनाम [i] कॉन्स्ट
ऑपरेशन stringName[i] const stringName[i] के बजाय निष्पादित किया जाता है जब स्ट्रिंग ऑब्जेक्ट एक स्थिर वस्तु होती है। यह उदाहरण के लिए निम्नलिखित कोड में प्रयोग किया जाता है:
स्थिरांकस्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');charचौधरी=strCol[4];
लागत<<चौधरी<< 'एन';
व्यंजक i . का निरंतर संदर्भ देता हैवांस्ट्रिंग ऑब्जेक्ट का तत्व। स्ट्रिंग के किसी भी तत्व को बदला नहीं जा सकता है।
सबस्क्रिप्ट के साथ एक कैरेक्टर असाइन करना
एक चरित्र को एक गैर-स्थिर स्ट्रिंग ऑब्जेक्ट को निम्नानुसार सौंपा जा सकता है:
स्ट्रिंग strCol=डोरी('मैंने कॉल की');strCol[2] = 'एफ';
लागत<<strCol<< 'एन';
आउटपुट आई फॉल है। 'सी' को 'एफ' में बदल दिया गया था।
stringName.at(i)
stringName.at(i) stringName[i] के समान है, लेकिन stringName.at(i) अधिक विश्वसनीय है। निम्नलिखित कोड दिखाता है कि इसका उपयोग कैसे किया जाना चाहिए:
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');charचौधरी=स्ट्रकॉलपर(4);
लागत<<चौधरी<< 'एन';
at() वास्तव में एक स्ट्रिंग क्लास सदस्य फ़ंक्शन है।
stringName.at(i) const
stringName.at(i) const stringName[i] const के समान है, लेकिन stringName.at(i) const अधिक विश्वसनीय है। stringName.at(i) const को stringName.at(i) के बजाय निष्पादित किया जाता है जब स्ट्रिंग ऑब्जेक्ट एक स्थिर स्ट्रिंग ऑब्जेक्ट होता है। इसका उपयोग निम्नलिखित कोड में किया जाता है, उदाहरण के लिए:
स्थिरांकस्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');charचौधरी=स्ट्रकॉलपर(4);
लागत<<चौधरी<< 'एन';
at() const वास्तव में एक स्ट्रिंग क्लास सदस्य फ़ंक्शन है।
at() फ़ंक्शन के साथ एक मान असाइन करना
एक गैर-स्थिर स्ट्रिंग ऑब्जेक्ट को एक मान असाइन किया जा सकता है, जिसमें () फ़ंक्शन, निम्नानुसार है:
स्ट्रिंग strCol=डोरी('मैंने कॉल की');स्ट्रकॉलपर(2) = 'एफ';
लागत<<strCol<< 'एन';
आउटपुट आई फॉल है।
सब-स्क्रिप्टिंग के साथ समस्या
सब-स्क्रिप्टिंग (इंडेक्सिंग) के साथ समस्या यह है कि यदि इंडेक्स सीमा से बाहर है, तो गलत परिणाम प्राप्त हो सकता है, या रन-टाइम पर एक त्रुटि जारी की जा सकती है।
सामने()
यह तत्व को हटाए बिना, स्ट्रिंग ऑब्जेक्ट के पहले तत्व का संदर्भ देता है। निम्नलिखित कोड का आउटपुट 'I' है।
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');charचौधरी=स्ट्रकॉलसामने();
लागत<<चौधरी<< 'एन';
वर्ण स्ट्रिंग ऑब्जेक्ट से हटाया नहीं जाता है।
सामने () स्थिरांक
जब स्ट्रिंग ऑब्जेक्ट निर्माण को कॉन्स्ट से पहले किया जाता है, तो सामने () के बजाय एक्सप्रेशन फ्रंट () कॉन्स्ट को निष्पादित किया जाता है। इसका उपयोग निम्नलिखित कोड में किया जाता है, उदाहरण के लिए।
स्थिरांकस्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');charचौधरी=स्ट्रकॉलसामने();
लागत<<चौधरी<< 'एन';
एक निरंतर संदर्भ लौटाया जाता है। तत्व को स्ट्रिंग ऑब्जेक्ट से नहीं हटाया जाता है। निरंतर स्ट्रिंग ऑब्जेक्ट के लिए कोई वर्ण नहीं बदला जा सकता है।
वापस()
यह तत्व को हटाए बिना, स्ट्रिंग ऑब्जेक्ट के अंतिम तत्व का संदर्भ देता है। निम्नलिखित कोड का आउटपुट 'u' है।
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');charचौधरी=स्ट्रकॉलवापस();
लागत<<चौधरी<< 'एन';
पीछे () स्थिरांक
जब स्ट्रिंग ऑब्जेक्ट का निर्माण कॉन्स्ट से पहले होता है, तो बैक () के बजाय एक्सप्रेशन बैक () कॉन्स्टेबल निष्पादित किया जाता है। इसका उपयोग निम्नलिखित कोड में किया जाता है, उदाहरण के लिए।
स्थिरांकस्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');charचौधरी=स्ट्रकॉलवापस();
लागत<<चौधरी<< 'एन';
एक निरंतर संदर्भ लौटाया जाता है। तत्व को स्ट्रिंग ऑब्जेक्ट से नहीं हटाया जाता है।
स्ट्रिंग क्षमता
size_type क्षमता () const noexcept
पुन: आबंटन की आवश्यकता के बिना स्ट्रिंग द्वारा धारण किए जा सकने वाले वर्णों की कुल संख्या, इस क्षमता सदस्य फ़ंक्शन द्वारा वापस की जाती है। इसके लिए एक कोड खंड है:
स्ट्रिंग strCol=डोरी();NSएक पर=स्ट्रकॉलक्षमता();
लागत<<एक पर<< 'एन';
मेरे कंप्यूटर पर आउटपुट 15 है।
आरक्षित (एन)
मेमोरी स्पेस हमेशा फ्री स्टोर में उपलब्ध नहीं होता है। अतिरिक्त स्थान अग्रिम में आरक्षित किया जा सकता है। निम्नलिखित कोड खंड पर विचार करें:
स्ट्रिंग strCol=डोरी('प्यार');स्ट्रकॉलरिज़र्व(6);
लागत<<स्ट्रकॉलक्षमता() << 'एन';
मेरे कंप्यूटर पर आउटपुट 15 है।
आकार () बिना किसी अपवाद के;
यह स्ट्रिंग में वर्णों की संख्या देता है। निम्नलिखित कोड दिखाता है:
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');NSएक पर=स्ट्रकॉलआकार();
लागत<<एक पर<< 'एन';
आउटपुट 10 है, जिसमें नल, वर्ण शामिल नहीं है।
लंबाई () बिना किसी अपवाद के
-आकार के समान().ध्यान दें:आकार() <=क्षमता().
जमा करने के लिए हटना()
पुन: आवंटन के कारण क्षमता () को आकार () में कम कर सकते हैं; यह अनिवार्य नहीं है। निम्नलिखित कोड इसे प्रदर्शित करता है:
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');स्ट्रकॉलरिज़र्व(12);
स्ट्रकॉलजमा करने के लिए हटना();
NSएस=स्ट्रकॉलआकार();
लागत<<एस<< 'एन';
आउटपुट 10 है और 12 या 16 नहीं है। फ़ंक्शन शून्य हो जाता है।
आकार बदलें (sz), आकार बदलें (sz, 'c')
यह स्ट्रिंग का आकार बदलता है। यदि नया आकार पुराने आकार से छोटा है, तो अंत की ओर के तत्व मिटा दिए जाते हैं। यदि नया आकार लंबा है, तो अंत में कुछ डिफ़ॉल्ट वर्ण जोड़ा जाता है। किसी विशेष वर्ण को जोड़ने के लिए, दो तर्कों के साथ आकार बदलें () फ़ंक्शन का उपयोग करें। निम्नलिखित कोड खंड दो कार्यों के उपयोग को दर्शाता है:
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');स्ट्रकॉलआकार(6);
लागत<< 'स्ट्रकोल का नया आकार:' <<स्ट्रकॉलआकार() << 'एन';
स्ट्रिंग strCol1=डोरी('मैं प्यार करती हूं', 'और');
strCol1.आकार(12);
लागत<< 'strCol1 का नया आकार:' <<strCol1.आकार() << 'एन';
आउटपुट है:
strCol का नया आकार: 6strCol1 का नया आकार: 12
फ़ंक्शन शून्य लौटाता है।
स्पष्ट () कोई अपवाद नहीं
स्ट्रिंग से सभी तत्वों को हटा देता है, जैसा कि निम्न कोड खंड दिखाता है:
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');स्ट्रकॉलस्पष्ट();
लागत<<स्ट्रकॉलआकार() << 'एन';
आउटपुट 0 है। फ़ंक्शन शून्य लौटाता है।
खाली () स्थिरांक कोई अपवाद नहीं है
यदि स्ट्रिंग ऑब्जेक्ट में कोई वर्ण नहीं है, तो यह सत्य के लिए 1 देता है, या स्ट्रिंग ऑब्जेक्ट खाली नहीं होने पर असत्य के लिए 0 देता है। निम्नलिखित कोड इसे दिखाता है:
स्ट्रिंग strCol1=डोरी('मैं तुमसे प्यार करता हूँ');लागत<<strCol1.खाली() << 'एन';
स्ट्रिंग strCol2=डोरी();
लागत<<strCol2.खाली() << 'एन';
आउटपुट है:
01
रिटर्निंग इटरेटर और स्ट्रिंग क्लास
एक पुनरावर्तक एक सूचक की तरह है लेकिन सूचक की तुलना में अधिक कार्यक्षमता है।
शुरू () कोई अपवाद नहीं
एक पुनरावर्तक देता है जो स्ट्रिंग ऑब्जेक्ट के पहले वर्ण (तत्व) को इंगित करता है, जैसा कि निम्न कोड खंड में है:
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');बेसिक_स्ट्रिंग<char> ::इटरेटरआईटीईआर=स्ट्रकॉलशुरू();
लागत<< *आईटीईआर<< 'एन';
आउटपुट 'मैं' है। ध्यान दें कि जिस तरह से इटरेटर प्राप्त करने वाली घोषणा घोषित की गई है। मान प्राप्त करने के लिए इटरेटर को रिटर्न एक्सप्रेशन में संदर्भित किया जाता है, उसी तरह, कि एक पॉइंटर को संदर्भित किया जाता है।
शुरू () बिना किसी अपवाद के;
एक पुनरावर्तक देता है जो स्ट्रिंग ऑब्जेक्ट संग्रह के पहले तत्व को इंगित करता है। जब ऑब्जेक्ट कंस्ट्रक्शन कॉन्स्ट से पहले होता है, तो एक्सप्रेशन स्टार्ट () कॉन्स्ट को स्टार्ट () के बजाय निष्पादित किया जाता है। इस शर्त के तहत, वस्तु में संबंधित तत्व को संशोधित नहीं किया जा सकता है। इसका उपयोग निम्नलिखित कोड में किया जाता है, उदाहरण के लिए।
स्थिरांकस्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');बेसिक_स्ट्रिंग<char> ::const_iteratorआईटीईआर=स्ट्रकॉलशुरू();
लागत<< *आईटीईआर<< 'एन';
आउटपुट 'मैं' है। ध्यान दें कि इस बार लौटाए गए पुनरावर्तक को प्राप्त करने के लिए, केवल पुनरावर्तक के बजाय, const_iterator का उपयोग किया गया है।
अंत () कोई अपवाद नहीं
एक पुनरावर्तक देता है जो स्ट्रिंग ऑब्जेक्ट के अंतिम तत्व से तुरंत आगे इंगित करता है। निम्नलिखित कोड खंड पर विचार करें:
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');बेसिक_स्ट्रिंग<char> ::इटरेटरआईटीईआर=स्ट्रकॉलसमाप्त();
लागत<< *आईटीईआर<< 'एन';
आउटपुट शून्य है, जो कुछ भी नहीं है, क्योंकि अंतिम तत्व से परे कोई ठोस तत्व नहीं है।
अंत () स्थिरांक कोई अपवाद नहीं है
एक पुनरावर्तक देता है जो स्ट्रिंग ऑब्जेक्ट के अंतिम तत्व से तुरंत आगे इंगित करता है। जब स्ट्रिंग ऑब्जेक्ट का निर्माण कॉन्स्ट से पहले होता है, तो एक्सप्रेशन एंड () कॉन्स्ट को एंड () के बजाय निष्पादित किया जाता है। निम्नलिखित कोड खंड पर विचार करें:
स्थिरांकस्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');बेसिक_स्ट्रिंग<char> ::const_iteratorआईटीईआर=स्ट्रकॉलसमाप्त();
लागत<< *आईटीईआर<< 'एन';
आउटपुट शून्य है। ध्यान दें कि इस बार लौटाए गए पुनरावर्तक को प्राप्त करने के लिए, केवल पुनरावर्तक के बजाय, const_iterator का उपयोग किया गया है।
रिवर्स इटरेशन
एक पुनरावर्तक होना संभव है जो वास्तविक अंत से पहले तत्व से ठीक पहले पुनरावृत्त हो:
rbegin () कोई अपवाद नहीं
एक पुनरावर्तक लौटाता है जो निम्नलिखित कोड खंड के रूप में, स्ट्रिंग तत्काल वस्तु के अंतिम तत्व को इंगित करता है:
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');बेसिक_स्ट्रिंग<char> ::रिवर्स_इटरेटरआईटीईआर=स्ट्रकॉलरबेगिन();
लागत<< *आईटीईआर<< 'एन';
आउटपुट 'यू' है। ध्यान दें कि जिस तरह से रिवर्स इटरेटर प्राप्त करने वाली घोषणा घोषित की गई है। मान प्राप्त करने के लिए इटरेटर को रिटर्न एक्सप्रेशन में संदर्भित किया जाता है, उसी तरह, कि एक पॉइंटर को संदर्भित किया जाता है।
rbegin () const noexcept;
एक पुनरावर्तक देता है जो स्ट्रिंग ऑब्जेक्ट के अंतिम तत्व को इंगित करता है। जब ऑब्जेक्ट निर्माण कॉन्स्ट से पहले होता है, तो अभिव्यक्ति rbegin() const को rbegin() के बजाय निष्पादित किया जाता है। इस शर्त के तहत, वस्तु में संबंधित तत्व को संशोधित नहीं किया जा सकता है। उदाहरण के लिए, निम्न कोड में सुविधा का उपयोग किया जाता है।
स्थिरांकस्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');बेसिक_स्ट्रिंग<char> ::const_reverse_iteratorआईटीईआर=स्ट्रकॉलरबेगिन();
लागत<< *आईटीईआर<< 'एन';
आउटपुट 'यू' है। ध्यान दें कि इस बार लौटाए गए इटरेटर को प्राप्त करने के लिए, केवल रिवर्स_इटरेटर के बजाय, const_reverse_iterator का उपयोग किया गया है।
रेंडर () कोई अपवाद नहीं
एक पुनरावर्तक देता है जो स्ट्रिंग ऑब्जेक्ट के पहले तत्व से ठीक पहले इंगित करता है। निम्नलिखित कोड खंड पर विचार करें:
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');बेसिक_स्ट्रिंग<char> ::रिवर्स_इटरेटरआईटीईआर=स्ट्रकॉलबनाता है();
लागत<< *आईटीईआर<< 'एन';
आउटपुट शून्य है, जो कुछ भी नहीं है, क्योंकि पहले तत्व के ठीक पहले कोई ठोस तत्व नहीं है।
रेंडर () const noexcept
एक पुनरावर्तक देता है जो स्ट्रिंग ऑब्जेक्ट के पहले तत्व से ठीक पहले इंगित करता है। जब ऑब्जेक्ट निर्माण कॉन्स्ट से पहले होता है, तो अभिव्यक्ति रेंडर () कॉन्स्ट को रेंडर () के बजाय निष्पादित किया जाता है। निम्नलिखित कोड खंड पर विचार करें:
स्थिरांकस्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');बेसिक_स्ट्रिंग<char> ::const_reverse_iteratorआईटीईआर=स्ट्रकॉलबनाता है();
लागत<< *आईटीईआर<< 'एन';
आउटपुट शून्य है। ध्यान दें कि इस बार लौटाए गए इटरेटर को प्राप्त करने के लिए, केवल रिवर्स_इटरेटर के बजाय, const_reverse_iterator का उपयोग किया गया है।
स्ट्रिंग संशोधक
एक संशोधक जो स्ट्रिंग ऑब्जेक्ट को संशोधित करता है, एक पुनरावर्तक भी ले या वापस कर सकता है।
जोड़कर
बेसिक_स्ट्रिंगऔरऑपरेटर+ =(स्थिरांकबेसिक_स्ट्रिंगऔरपी)दाएं स्ट्रिंग ऑब्जेक्ट को बाएं स्ट्रिंग ऑब्जेक्ट में जोड़ता है। उदाहरण:
स्ट्रिंग strCol1=डोरी('मैं प्यार करती हूं');स्ट्रिंग strCol2=डोरी(' आप');
strCol1+ =strCol2;
लागत<<strCol1<< 'एन';
आउटपुट है आई लव यू। यह न भूलें कि strCol1 += strCol2 strCol1 = strCol1+strCol2 के समान है।
बेसिक_स्ट्रिंग और ऑपरेटर + = (कॉन्स्ट चार्ट * एस)
स्ट्रिंग ऑब्जेक्ट संग्रह में एक स्ट्रिंग अक्षर जोड़ता है। उदाहरण:
स्ट्रिंग strCol=डोरी('मैं प्यार करती हूं');strCol+ = ' आप';
लागत<<strCol<< 'एन';
आउटपुट: आई लव यू।
बेसिक_स्ट्रिंग और ऑपरेटर+=(charT c)
ऑब्जेक्ट स्ट्रिंग में एकल वर्ण जोड़ता है। उदाहरण:
स्ट्रिंग strCol=डोरी('मैं आपसे प्यार करता हूँ');strCol+ = 'यू';
लागत<<strCol<< 'एन';
आउटपुट: आई लव यू।
बेसिक_स्ट्रिंग और ऑपरेटर + = (इनिशियलाइज़र_लिस्ट)
एक प्रारंभकर्ता सूची जोड़ता है। उदाहरण:
स्ट्रिंग strCol=डोरी('मैं प्यार करती हूं');strCol+ = {'','तथा','या','यू',' 0'};
लागत<<strCol<< 'एन';
आउटपुट: आई लव यू। वर्ण प्रारंभकर्ता सूची के अंत में nul, जोड़ना हमेशा अच्छा होता है।
बेसिक_स्ट्रिंग और एपेंड (कॉन्स्ट बेसिक_स्ट्रिंग और स्ट्र)
तर्क स्ट्रिंग ऑब्जेक्ट को मुख्य स्ट्रिंग ऑब्जेक्ट में जोड़ता है। उदाहरण:
स्ट्रिंग strCol1=डोरी('मैं प्यार करती हूं');स्ट्रिंग strCol2=डोरी(' आप');
strCol1.संलग्न(strCol2);
लागत<<strCol1<< 'एन';
आउटपुट: आई लव यू।
बेसिक_स्ट्रिंग और एपेंड (कॉन्स्ट चार्ट * एस)
मुख्य स्ट्रिंग में एक स्ट्रिंग शाब्दिक तर्क जोड़ता है। उदाहरण
स्ट्रिंग strCol=डोरी('मैं प्यार करती हूं');strCol=स्ट्रकॉलसंलग्न(' आप');
लागत<<strCol<< 'एन';
आउटपुट: आई लव यू।
मूल_स्ट्रिंग और संलग्न करें (प्रारंभकर्ता_सूची)
इनिशियलाइज़र सूची को जोड़ता है, जो मुख्य स्ट्रिंग में एक तर्क है। उदाहरण:
स्ट्रिंग strCol=डोरी('मैं प्यार करती हूं');strCol=स्ट्रकॉलसंलग्न({'','तथा','या','यू',' 0'});
लागत<<strCol<< 'एन';
आउटपुट: आई लव यू। प्रारंभकर्ता सूची के अंत में शून्य, वर्ण जोड़ना हमेशा अच्छा होता है।
बेसिक_स्ट्रिंग और एपेंड (size_type n, charT c)
एक ही वर्ण के n को जोड़ता है। उदाहरण:
स्ट्रिंग strCol=डोरी('टैब');strCol=स्ट्रकॉलसंलग्न(2, 'या');
लागत<<strCol<< 'एन';
आउटपुट: वर्जित।
मूल_स्ट्रिंग और संलग्न करें (स्थिरांक charT* s, size_type n)
एक स्ट्रिंग अक्षर के पहले n तत्वों को मुख्य स्ट्रिंग ऑब्जेक्ट में जोड़ता है। उदाहरण:
स्ट्रिंग strCol=डोरी('मैं प्यार करती हूं');strCol=स्ट्रकॉलसंलग्न(' तो तुम', 4);
लागत<<strCol<< 'एन';
आउटपुट है: आई लव यू। यदि n शाब्दिक की लंबाई से अधिक है, तो एक length_error अपवाद फेंक दिया जाता है।
बेसिक_स्ट्रिंग और एपेंड (कॉन्स्ट बेसिक_स्ट्रिंग और स्ट्र, साइज_टाइप पॉज़, साइज़_टाइप एन = एनपीओएस)
अनुक्रमणिका से n वर्ण जोड़ता है, मुख्य स्ट्रिंग में पोज़ करता है। उदाहरण:
स्ट्रिंग strCol=डोरी('मैं प्यार करती हूं');strCol=स्ट्रकॉलसंलग्न('क्या तुम ऐसा हो', 2, 4);
लागत<<strCol<< 'एन';
आउटपुट: आई लव यू। यहां एक अपवाद भी फेंका जाएगा, बाद में देखें।
नियत
बेसिक_स्ट्रिंगऔरअसाइन(स्थिरांकबेसिक_स्ट्रिंगऔरपी)तर्क स्ट्रिंग ऑब्जेक्ट को मुख्य स्ट्रिंग पर असाइन करता है, जो वहां मौजूद किसी भी सामग्री को प्रतिस्थापित करता है।
स्ट्रिंग strCol1=डोरी('मैं तुमसे प्यार करता हूँ');स्ट्रिंग strCol2=डोरी('उसे मेरी जरूरत है');
strCol1=strCol1.असाइन(strCol2);
लागत<<strCol1<< 'एन';
आउटपुट: उसे मेरी जरूरत है।
बेसिक_स्ट्रिंगऔरअसाइन(स्थिरांकचार्ट*एस)मुख्य स्ट्रिंग के लिए एक स्ट्रिंग शाब्दिक तर्क असाइन करता है, जो वहां मौजूद किसी भी सामग्री को प्रतिस्थापित करता है।
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');strCol=स्ट्रकॉलअसाइन('उसे मेरी जरूरत है');
लागत<<strCol<< 'एन';
आउटपुट: उसे मेरी जरूरत है।
बेसिक_स्ट्रिंगऔरअसाइन(प्रारंभकर्ता_सूची<चार्ट>)मुख्य स्ट्रिंग के लिए प्रारंभकर्ता सूची तर्क असाइन करता है,वहां मौजूद किसी भी सामग्री को बदलना।
[सीसी लैंग='सी'भाग निकले='सच'चौड़ाई='780']
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');
strCol=स्ट्रकॉलअसाइन({'एस','एच','और','','एन','और','और','डी','एस','','एम','और',' 0'});
लागत<<strCol<< 'एन';
आउटपुट: उसे मेरी जरूरत है। स्ट्रिंग अक्षर बनाने के लिए हमेशा वर्ण सूची के अंत में nul, जोड़ना अच्छा होता है।
बेसिक_स्ट्रिंगऔरअसाइन(स्थिरांकचार्ट*एस,size_type n)एक स्ट्रिंग शाब्दिक तर्क के पहले n वर्णों को मुख्य स्ट्रिंग में असाइन करता है, जो वहां मौजूद किसी भी सामग्री को प्रतिस्थापित करता है।
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');strCol=स्ट्रकॉलअसाइन('उसे मेरी जरूरत है', 9);
लागत<<strCol<< 'एन';
आउटपुट: उसे चाहिए।
बेसिक_स्ट्रिंगऔरअसाइन(size_type n,चार्ट सी)मुख्य स्ट्रिंग में समान वर्णों के n का तर्क निर्दिष्ट करता है, जो वहां मौजूद किसी भी सामग्री को प्रतिस्थापित करता है।
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');strCol=स्ट्रकॉलअसाइन(4, 'और');
लागत<<strCol<< 'एन';
आउटपुट: ईईईईई
बेसिक_स्ट्रिंगऔरअसाइन(स्थिरांकबेसिक_स्ट्रिंगऔरपी,आकार_प्रकार स्थिति,size_type n=एनपीओ)
किसी स्ट्रिंग ऑब्जेक्ट तर्क के n वर्ण निर्दिष्ट करता है, पॉज़ से शुरू होकर, मुख्य स्ट्रिंग तक, वहां मौजूद किसी भी सामग्री को प्रतिस्थापित करता है।
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');strCol=स्ट्रकॉलअसाइन('उसे मेरी जरूरत है', 4, 5);
लागत<<strCol<< 'एन';
आउटपुट: जरूरत है। एक अपवाद फेंक देंगे - बाद में देखें।
डालने
बेसिक_स्ट्रिंगऔरडालने(आकार_प्रकार स्थिति, स्थिरांकबेसिक_स्ट्रिंगऔरपी)स्ट्रिंग ऑब्जेक्ट तर्क को मुख्य स्ट्रिंग में, इंडेक्स, पॉज़ पर सम्मिलित करता है।
स्ट्रिंग strCol1=डोरी('मैं तुमसे प्यार करता हूँ');स्ट्रिंग strCol2=डोरी('नफरत और');
strCol1=strCol1.डालने(2,strCol2);
लागत<<strCol1<< 'एन';
आउटपुट: आई हेट एंड लव यू। एक अपवाद फेंक देंगे - बाद में देखें।
बेसिक_स्ट्रिंगऔरडालने(size_type pos1, स्थिरांकबेसिक_स्ट्रिंगऔरपी,size_type pos2,size_type n=एनपीओ)
स्ट्रिंग ऑब्जेक्ट तर्क के pos2 से मुख्य स्ट्रिंग तक, अनुक्रमणिका, pos1 पर n वर्णों की लंबाई सम्मिलित करता है।
स्ट्रिंग strCol1=डोरी('मैं तुमसे प्यार करता हूँ');स्ट्रिंग strCol2=डोरी('नफरत, चाहत और जरूरत');
strCol1=strCol1.डालने(2,strCol2, 6, 9);
लागत<<strCol1<< 'एन';
आउटपुट: आई वांट एंड लव यू।
इटरेटर इन्सर्ट (const_iterator p, charT c)
इटरेटर द्वारा इंगित स्थिति में एक विशेष वर्ण, जो एक तर्क है, सम्मिलित करता है। नए डाले गए चरित्र की स्थिति के लिए एक पुनरावर्तक देता है।
स्ट्रिंग strCol=डोरी('मैं तुमसे प्यार करता हूँ');बेसिक_स्ट्रिंग<char> ::इटरेटरआईटीईआर=स्ट्रकॉलशुरू();
++आईटीईआर; ++आईटीईआर; ++आईटीईआर; ++आईटीईआर; ++आईटीईआर; ++आईटीईआर;
बेसिक_स्ट्रिंग<char> ::इटरेटरनेटवर्क=स्ट्रकॉलडालने(आईटीईआर, 'डी');
लागत<< *नेटवर्क<< 'एन';
लागत<<strCol<< 'एन';
आउटपुट है:
'डी'
मैंने तुम्हें प्यार किया
इटरेटर इन्सर्ट (const_iterator p, size_type n, charT c)
तर्क के समान वर्ण के n को पुनरावृत्त द्वारा इंगित स्थिति में सम्मिलित करता है। नए डाले गए समान वर्णों की शुरुआत की स्थिति के लिए एक पुनरावर्तक देता है।
स्ट्रिंग strCol=डोरी('भूमि में टैब।');बेसिक_स्ट्रिंग<char> ::इटरेटरआईटीईआर=स्ट्रकॉलशुरू();
++आईटीईआर; ++आईटीईआर; ++आईटीईआर;
बेसिक_स्ट्रिंग<char> ::इटरेटरनेटवर्क=स्ट्रकॉलडालने(आईटीईआर, 2, 'या');
लागत<< *नेटवर्क<< 'एन';
लागत<<strCol<< 'एन';
आउटपुट है:
'या'
भूमि में वर्जित।
बेसिक_स्ट्रिंगऔरडालने(आकार_प्रकार स्थिति, स्थिरांकचार्ट*एस)इंडेक्स में एक तर्क स्ट्रिंग शाब्दिक सम्मिलित करता है, मुख्य स्ट्रिंग में पॉज़ करता है।
स्ट्रिंग strCol=डोरी('भूमि में टैब।');strCol=स्ट्रकॉलडालने(3, 'ऊ');
लागत<<strCol<< 'एन';
आउटपुट: भूमि में वर्जित।
बेसिक_स्ट्रिंगऔरडालने(आकार_प्रकार स्थिति, स्थिरांकचार्ट*एस,size_type n)मुख्य स्ट्रिंग में इंडेक्स, पॉज़ पर तर्क स्ट्रिंग अक्षर के पहले n अक्षर डालें।
स्ट्रिंग strCol=डोरी('भूमि में टैब।');strCol=स्ट्रकॉलडालने(3, 'ओउ', 2);
लागत<<strCol<< 'एन';
आउटपुट: भूमि में वर्जित।
की जगह
बेसिक_स्ट्रिंगऔरबदलने के(size_type pos1,size_type n1, स्थिरांकबेसिक_स्ट्रिंगऔरपी))मुख्य स्ट्रिंग ऑब्जेक्ट में इंडेक्स, pos1 से n1 वर्णों को तर्क स्ट्रिंग ऑब्जेक्ट के साथ बदलता है।
स्ट्रिंग strCol1=डोरी('मैं तुमसे प्यार करता हूँ');स्ट्रिंग strCol2=डोरी('तुमसे नफरत है और');
strCol1=strCol1.बदलने के(2, 4,strCol2);
लागत<<strCol1<< 'एन';
आउटपुट: आई हेट यू एंड यू। एक अपवाद फेंक देंगे - बाद में देखें।
बेसिक_स्ट्रिंगऔरबदलने के(size_type pos1,size_type n1, स्थिरांकबेसिक_स्ट्रिंगऔरपी,size_type pos2,size_type n2=एनपीओ)
इंडेक्स, pos1 से मुख्य स्ट्रिंग ऑब्जेक्ट में n1 वर्णों को इंडेक्स, pos2 से तर्क स्ट्रिंग ऑब्जेक्ट के n2 वर्णों के साथ बदलता है।
स्ट्रिंग strCol1=डोरी('मैं तुमसे प्यार करता हूँ');स्ट्रिंग strCol2=डोरी('हम उससे और उससे नफरत करते हैं');
strCol1=strCol1.बदलने के(2, 4,strCol2, 3, 12);
लागत<<strCol1<< 'एन';
आउटपुट: मैं उससे और तुमसे नफरत करता हूँ।
बेसिक_स्ट्रिंगऔरबदलने के(size_type pos1,size_type n1, स्थिरांकचार्ट*एस,size_type n2)
इंडेक्स से मुख्य स्ट्रिंग ऑब्जेक्ट में n1 वर्णों को प्रतिस्थापित करता है, pos1, शाब्दिक स्ट्रिंग तर्क के पहले n2 वर्णों के साथ।
स्ट्रिंग strCol1=डोरी('मैं तुमसे प्यार करता हूँ');strCol1=strCol1.बदलने के(2, 4, 'उससे और उससे नफरत करो', 12);
लागत<<strCol1<< 'एन';
आउटपुट: मैं उससे और तुमसे नफरत करता हूँ।
मूल_स्ट्रिंग और प्रतिस्थापित करें (आकार_प्रकार स्थिति, आकार_प्रकार एन, कॉन्स चार्ट * एस)
शाब्दिक स्ट्रिंग तर्क के साथ इंडेक्स, पॉज़ से मुख्य स्ट्रिंग ऑब्जेक्ट में n वर्णों को प्रतिस्थापित करता है।
स्ट्रिंग strCol1=डोरी('मैं तुमसे प्यार करता हूँ');strCol1=strCol1.बदलने के(2, 4, 'उससे नफरत और');
लागत<<strCol1<< 'एन';
आउटपुट: मैं उससे और तुमसे नफरत करता हूँ।
बेसिक_स्ट्रिंगऔरबदलने के(size_type pos1,size_type n1,size_type n2,चार्ट सी)इंडेक्स, pos1 से मुख्य स्ट्रिंग ऑब्जेक्ट में n1 वर्णों को तर्क के समान वर्ण के n2 से बदल देता है।
स्ट्रिंग strCol1=डोरी('वहां एक खराब टैबलेट।');strCol1=strCol1.बदलने के(9, 3, 2, 'या');
लागत<<strCol1<< 'एन';
आउटपुट: वहाँ एक बुरा वर्जित ..
इटरेटर इरेज़ (const_iterator p)
इटरेटर द्वारा इंगित स्थिति पर एक चरित्र को हटा देता है; फिर पुनरावर्तक स्थिति देता है, जो अब उस चरित्र द्वारा कब्जा कर लिया गया है जो इस चरित्र (या अंत ()) के बगल में था। निम्नलिखित कोड इसे दिखाता है:
स्ट्रिंग strCol=डोरी('ऐ बी सी डी');बेसिक_स्ट्रिंग<char> ::इटरेटरआईटीईआर=स्ट्रकॉलशुरू();
++आईटीईआर; ++आईटीईआर;
स्ट्रकॉलमिटा(आईटीईआर);
लागत<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< 'एन';
आउटपुट: ए बी डी
बेसिक_स्ट्रिंगऔरमिटा(आकार_प्रकार स्थिति= 0,size_type n=एनपीओ)अनुक्रमणिका से n वर्ण निकालता है, pos.
स्ट्रिंग strCol=डोरी('ऐ बी सी डी');स्ट्रकॉलमिटा(1, 2);
लागत<<strCol[0] << '' <<strCol[1] << 'एन';
आउटपुट: एक डी
शून्य push_back (charT c)
स्ट्रिंग के अंत में एक वर्ण जोड़ने के लिए:
स्ट्रिंग strCol=डोरी('ऐ बी सी डी');स्ट्रकॉलवापस धक्का देना('5');
लागत<<strCol<< 'एन';
आउटपुट: एबीसीडी5
शून्य पॉप_बैक ()
अंतिम चरित्र को वापस किए बिना हटा देता है। स्ट्रिंग का आकार 1 से कम हो जाता है।
स्ट्रिंग strCol=डोरी('एबीसीडीई');स्ट्रकॉलपॉप_बैक();
लागत<<strCol<< 'एन';
आउटपुट: एबीसीडी
शून्य स्वैप (basic_string& s)
दो स्ट्रिंग ऑब्जेक्ट्स के अक्षर को स्वैप किया जा सकता है।
स्ट्रिंग strCol1=डोरी(<सहायता='पोस्ट-69618-__DdeLink__781_3724385525'>प्रति>'एबीसीडीई');स्ट्रिंग strCol2=डोरी('1234567');
strCol1.विनिमय(strCol2);
लागत<<strCol1<< 'एन';
लागत<<strCol2<< 'एन';
आउटपुट है:
'1234567''एबीसीडीई'
स्ट्रिंग ऑपरेशंस
कास्ट चार्ट* c_str () बिना किसी अपवाद के;
स्ट्रिंग के पहले तत्व के लिए एक पॉइंटर लौटाता है। सूचक बढ़ाया जा सकता है।
स्थिरांकस्ट्रिंग strCol=डोरी('एबीसीडीई');स्थिरांक char*पी=स्ट्रकॉलc_str();
लागत<< *पी<< 'एन';
++पी;
लागत<< *पी<< 'एन';
आउटपुट है:
प्रतिबी
हेडिंग में दूसरे कॉन्स्टेबल होने के कारण प्रोग्राम स्ट्रिंग में किसी भी कैरेक्टर को नहीं बदल सकता है। निर्माण कॉन्स्ट से पहले होता है।
कास्ट चार्ट* डेटा () कॉन्स्ट नोएक्सेप्टेड
स्ट्रिंग के पहले तत्व के लिए एक पॉइंटर लौटाता है। सूचक बढ़ाया जा सकता है।
स्थिरांकस्ट्रिंग strCol=डोरी('एबीसीडीई');स्थिरांक char*पी=स्ट्रकॉलआंकड़े();
लागत<< *पी<< 'एन';
++पी;
लागत<< *पी<< 'एन';
आउटपुट है:
प्रतिबी
हेडिंग में दूसरे कॉन्स्टेबल होने के कारण प्रोग्राम स्ट्रिंग में किसी भी कैरेक्टर को नहीं बदल सकता है। निर्माण कॉन्स्ट से पहले होता है।
बेसिक_स्ट्रिंग सबस्ट्र (आकार_टाइप पॉज़ = 0, साइज़_टाइप एन = एनपीओएस) कॉन्स्ट
इंडेक्स, पॉज़ से शुरू होने वाली उप-स्ट्रिंग के लिए n वर्णों का एक स्ट्रिंग ऑब्जेक्ट देता है।
स्थिरांकस्ट्रिंग strCol=डोरी('abcdefghij');स्थिरांकस्ट्रिंग retStr=स्ट्रकॉलपदार्थ(2, 4);
लागत<<retStr<< 'एन';
आउटपुट: सीडीएफ
ढूँढें () सदस्य कार्य
size_type ढूंढें (कॉन्स्ट बेसिक_स्ट्रिंग और str, size_type pos = 0) const noexcept
इंडेक्स से शुरू होने वाली सब-स्ट्रिंग ऑब्जेक्ट की तलाश करता है, पॉज़। यदि पाया जाता है, तो मुख्य स्ट्रिंग में उप-स्ट्रिंग की शुरुआत लौटाता है।
स्ट्रिंग strCol=डोरी('हम दुनिया हैं!');स्ट्रिंग strCol1=डोरी('NS');
NSएक पर=स्ट्रकॉलपाना(strCol1, 2);
लागत<<एक पर<< 'एन';
आउटपुट:
सूचकांक: 7रिटर्न -1, जब नहीं मिला।
size_type ढूंढें (कॉन्स्ट charT* s, size_type pos = 0) const
इंडेक्स, पॉज़ से एक उप-स्ट्रिंग शाब्दिक शुरुआत की तलाश करता है। यदि पाया जाता है, तो मुख्य स्ट्रिंग में उप-स्ट्रिंग की शुरुआत लौटाता है।
स्ट्रिंग strCol=डोरी('हम दुनिया हैं!');NSएक पर=स्ट्रकॉलपाना('हैं', 0);
लागत<<एक पर<< 'एन';
चूँकि pos = 0 डिफ़ॉल्ट है, तर्क में 0 को छोड़ा जा सकता था।
आउटपुट: 3
रिटर्न -1, जब नहीं मिला।
size_type ढूंढें (const charT* s, size_type pos, size_type n) const
इंडेक्स, पॉज़ से शुरू होने वाले उप-स्ट्रिंग शाब्दिक के पहले n वर्णों की तलाश करता है। यदि पाया जाता है, तो मुख्य स्ट्रिंग में उप-स्ट्रिंग की शुरुआत लौटाता है।
स्ट्रिंग strCol=डोरी('सबसे बड़ा लड़का');NSएक पर=स्ट्रकॉलपाना('बड़ा', 1, 3);
लागत<<एक पर<< 'एन';
आउटपुट: 4
रिटर्न -1, जब नहीं मिला।
size_type ढूंढें (charT c, size_type pos = 0) const
चरित्र की तलाश करता है, सी सूचकांक से शुरू होता है, स्थिति। यदि पाया जाता है, तो मुख्य स्ट्रिंग में उप-स्ट्रिंग की शुरुआत लौटाता है। यदि नहीं मिला, तो -1 लौटाता है।
स्ट्रिंग strCol=डोरी('हम दुनिया हैं!');NSएक पर=स्ट्रकॉलपाना('साथ में');
लागत<<एक पर<< 'एन';
आउटपुट: -1
निम्नलिखित रिवर्स फाइंड () सदस्य फ़ंक्शन मौजूद हैं:
size_type rfind(स्थिरांकबेसिक_स्ट्रिंगऔरपी,आकार_प्रकार स्थिति=एनपीओ) स्थिरांकबिना किसी अपवाद के;size_type rfind(स्थिरांकचार्ट*एस,आकार_प्रकार स्थिति=एनपीओ) स्थिरांक;
size_type rfind(स्थिरांकचार्ट*एस,आकार_प्रकार स्थिति,size_type n) स्थिरांक;
size_type rfind(चार्ट सी,आकार_प्रकार स्थिति=एनपीओ) स्थिरांक;
तुलना सदस्य कार्य
इंट तुलना (कॉन्स्ट बेसिक_स्ट्रिंग और स्ट्र) कॉन्स्ट नोएक्सेसेप्ट
मुख्य स्ट्रिंग ऑब्जेक्ट के साथ तर्क स्ट्रिंग ऑब्जेक्ट की तुलना करता है। यदि मुख्य स्ट्रिंग तर्क (शब्दकोश में) से पहले होती है तो यह एक सकारात्मक संख्या देता है। यदि यह मुख्य स्ट्रिंग के बाद होता है, तो यह एक ऋणात्मक संख्या देता है। यदि दो तार समान हैं, तो यह शून्य लौटाता है।
स्ट्रिंग strCol1=डोरी('भीड़');स्ट्रिंग strCol2=डोरी('लोग');
NSएक पर=strCol1.तुलना करना(strCol2);
लागत<<एक पर<< 'एन';
आउटपुट: -13
इंट तुलना (कॉन्स्ट चार्ट टी * एस) कॉन्स्ट
ऊपर जैसा ही है, लेकिन तर्क एक स्ट्रिंग अक्षर है।
स्ट्रिंग strCol1=डोरी('लोग');NSएक पर=strCol1.तुलना करना('लोग');
लागत<<एक पर<< 'एन';
आउटपुट: 0
स्ट्रिंग ऑपरेटर्स
ये ऑपरेटर स्ट्रिंग ऑब्जेक्ट्स पर लागू होते हैं और जरूरी नहीं कि स्ट्रिंग लिटरल हों।
+
दो स्ट्रिंग ऑब्जेक्ट्स को जोड़ता है, और कॉन्सटेनेशन देता है।
स्ट्रिंग strCol1=डोरी('नाच');स्ट्रिंग strCol2=डोरी(' चांद');
स्ट्रिंग strCol=strCol1+strCol2;
लागत<<strCol<< 'एन';
आउटपुट: चाँद पर नृत्य।
==
यदि स्ट्रिंग ऑब्जेक्ट समान हैं, तो सत्य के लिए 1 लौटाता है; और असत्य के लिए शून्य, यदि वे नहीं हैं।
स्ट्रिंग strCol1=डोरी('नाच');स्ट्रिंग strCol2=डोरी(' चांद पर');
बूल ब्लू=strCol1==strCol2;
लागत<<बीएल<< 'एन';
आउटपुट: 0
! =
यदि स्ट्रिंग ऑब्जेक्ट समान नहीं हैं, तो 1 लौटाता है, और शून्य होने पर लौटाता है।
स्ट्रिंग strCol1=डोरी('नाच');स्ट्रिंग strCol2=डोरी(' चांद पर');
बूल ब्लू=strCol1! =strCol2;
लागत<<बीएल<< 'एन';
आउटपुट: 1
<
यदि डिक्शनरी के अनुसार बायां ऑपरेंड दाएं ऑपरेंड से कम है, या यदि नहीं है तो शून्य देता है।
स्ट्रिंग strCol1=डोरी('नाच');स्ट्रिंग strCol2=डोरी(' चांद पर');
बूल ब्लू=strCol1<strCol2;
लागत<<बीएल<< 'एन';
आउटपुट: 0
सी ++ में सामान्य वर्णों के लिए, आरोही क्रम में, संख्याएं अपरकेस अक्षरों से पहले आती हैं, जो लोअरकेस अक्षरों से पहले आती हैं। स्पेस कैरेक्टर शून्य और उन सभी से पहले आता है।
सी ++ मुख्य स्ट्रिंग कैरेक्टर प्रकार
char
चार प्रकार मूल सी ++ प्रकार है और आमतौर पर एक चरित्र को 8 बिट्स में संग्रहीत करता है।
char16_t
यह एक कैरेक्टर को 16 बिट्स में स्टोर करता है।
char32_t
यह एक कैरेक्टर को 32 बिट्स में स्टोर करता है।
wchar_t
char16_t और char32_t विस्तृत वर्ण हैं। wchar_t एक विस्तृत चरित्र है जो स्वामित्व और कार्यान्वयन-परिभाषित है।
इन प्रकारों को लक्षण कहा जाता है। हालाँकि, C ++ उन्हें तकनीकी रूप से, लक्षणों की विशेषज्ञता के रूप में संदर्भित करता है। यह लेख चार प्रकार पर केंद्रित है। अन्य प्रकारों के लिए दृष्टिकोण थोड़ा अलग है - बाद में देखें।
अन्य स्ट्रिंग ऑपरेशन सदस्य कार्य
अन्य स्ट्रिंग ऑपरेशन फ़ंक्शंस के हस्ताक्षर हैं:
size_type find_first_of(स्थिरांकबेसिक_स्ट्रिंगऔरपी,आकार_प्रकार स्थिति= 0) स्थिरांकबिना किसी अपवाद के;size_type find_first_of(स्थिरांकचार्ट*एस,आकार_प्रकार स्थिति,size_type n) स्थिरांक;
size_type find_first_of(स्थिरांकचार्ट*एस,आकार_प्रकार स्थिति= 0) स्थिरांक;
size_type find_first_of(चार्ट सी,आकार_प्रकार स्थिति= 0) स्थिरांक;
size_type find_last_of(स्थिरांकबेसिक_स्ट्रिंगऔरपी,आकार_प्रकार स्थिति=एनपीओ) स्थिरांकबिना किसी अपवाद के;
size_type find_last_of(स्थिरांकचार्ट*एस,आकार_प्रकार स्थिति,size_type n) स्थिरांक;
size_type find_last_of(स्थिरांकचार्ट*एस,आकार_प्रकार स्थिति=एनपीओ) स्थिरांक;
size_type find_last_of(चार्ट सी,आकार_प्रकार स्थिति=एनपीओ) स्थिरांक;
size_type find_first_not_of(स्थिरांकबेसिक_स्ट्रिंगऔरपी,आकार_प्रकार स्थिति= 0) स्थिरांकबिना किसी अपवाद के;
size_type find_first_not_of(स्थिरांकचार्ट*एस,आकार_प्रकार स्थिति,size_type n) स्थिरांक;
size_type find_first_not_of(स्थिरांकचार्ट*एस,आकार_प्रकार स्थिति= 0) स्थिरांक;
size_type find_first_not_of(चार्ट सी,आकार_प्रकार स्थिति= 0) स्थिरांक;
size_type find_last_not_of(स्थिरांकबेसिक_स्ट्रिंगऔरपी,आकार_प्रकार स्थिति=एनपीओ) स्थिरांकबिना किसी अपवाद के;
size_type find_last_not_of(स्थिरांकचार्ट*एस,आकार_प्रकार स्थिति,size_type n) स्थिरांक;
size_type find_last_not_of(स्थिरांकचार्ट*एस,आकार_प्रकार स्थिति=एनपीओ) स्थिरांक;
size_type find_last_not_of(चार्ट सी,आकार_प्रकार स्थिति=एनपीओ) स्थिरांक;
निष्कर्ष
सी ++ में स्ट्रिंग अक्षर और स्ट्रिंग ऑब्जेक्ट हैं। स्ट्रिंग ऑब्जेक्ट में अनुक्रम में वर्णों का एक संग्रह होता है, जो क्रम में वर्णों की एक सरणी के समान होता है। स्ट्रिंग संग्रह और सरणी के बीच का अंतर यह है कि स्ट्रिंग संग्रह लंबाई में बढ़ सकता है या लंबाई में सिकुड़ सकता है। एक स्ट्रिंग ऑब्जेक्ट को एक स्ट्रिंग क्लास से तत्काल (निर्मित) किया जाता है। एक स्ट्रिंग ऑब्जेक्ट सदस्य कार्यों के साथ एक डेटा संरचना है। सदस्य कार्यों को ऑब्जेक्ट निर्माण, तत्व पहुंच, स्ट्रिंग क्षमता, स्ट्रिंग सदस्य फ़ंक्शन के साथ इटरेटर तर्क और रिटर्न प्रकार, और स्ट्रिंग संशोधक के शीर्षकों के तहत वर्गीकृत किया जा सकता है। स्ट्रिंग समानता और संबंधपरक ऑपरेटर भी मौजूद हैं।