C++ प्रोग्रामिंग के क्षेत्र में, दक्षता और प्रदर्शन को प्राथमिकता देना महत्वपूर्ण है। C++17 में पेश किया गया 'std::string_view' वर्ग, पारंपरिक स्ट्रिंग हेरफेर के लिए एक बहुमुखी और मेमोरी-कुशल विकल्प प्रस्तुत करता है। इसके मूल में, 'std::string_view' वर्णों के अनुक्रम का एक गैर-स्वामित्व वाला संदर्भ है, जो आमतौर पर एक बड़ी स्ट्रिंग के सबस्ट्रिंग का प्रतिनिधित्व करता है। 'std::string' के विपरीत, जो अपने डेटा का स्वामी है और आंतरिक रूप से मेमोरी का प्रबंधन करता है, 'std::string_view' अंतर्निहित डेटा के स्वामित्व के बिना संचालित होता है। यह विशेषता इसे उन परिदृश्यों के लिए विशेष रूप से मूल्यवान बनाती है जहां मेमोरी को कॉपी करने या प्रबंधित करने का ओवरहेड अवांछनीय है। इस लेख में, हम C++ में 'std::string_view' के उपयोग को समझने के लिए विभिन्न उदाहरणों का पता लगाएंगे।
उदाहरण 1: कुशल स्ट्रिंग हैंडलिंग
आधुनिक C++ विकास में, प्रदर्शन और संसाधन उपयोग को अनुकूलित करने के लिए कुशल स्ट्रिंग हैंडलिंग महत्वपूर्ण है। यह मेमोरी पुनःआवंटन या दोहराव की आवश्यकता के बिना स्ट्रिंग्स की कुशल पहुंच और हेरफेर की अनुमति देता है। इस अवधारणा को स्पष्ट करने के लिए, आइए एक व्यावहारिक उदाहरण पर गौर करें।
निम्नलिखित कोड स्निपेट पर विचार करें:
#शामिल करें
#शामिल <स्ट्रिंग_व्यू>
शून्य प्रक्रियास्ट्रिंग दृश्य ( std::string_view strView ) {
std::cout << 'लंबाई: ' << strView.लंबाई ( ) << std::endl;
std::cout << 'सामग्री: ' << strView << std::endl;
}
मुख्य प्रवेश बिंदु ( ) {
std::स्ट्रिंग ओरिजिनलस्ट्रिंग = 'कुशल स्ट्रिंग हैंडलिंग' ;
std::string_view viewOfString ( मूलस्ट्रिंग ) ;
प्रोसेसस्ट्रिंग व्यू ( व्यूऑफस्ट्रिंग ) ;
वापस करना 0 ;
}
इस उदाहरण में, हमारे पास 'processStringView' फ़ंक्शन है जो 'std::string_view' को अपने पैरामीटर के रूप में लेता है। फ़ंक्शन तब मानक आउटपुट का उपयोग करके स्ट्रिंग दृश्य की लंबाई और सामग्री को प्रिंट करता है। मुख्य फ़ंक्शन 'ओरिजिनलस्ट्रिंग' नामक 'std::string' को 'कुशल स्ट्रिंग हैंडलिंग' मान के साथ प्रारंभ करता है। इसके बाद, 'viewOfString' नामक 'std::string_view' बनाया गया है, जो 'originalString' की सामग्री को संदर्भित करता है।
'व्यूऑफस्ट्रिंग' को 'प्रोसेसस्ट्रिंगव्यू' फ़ंक्शन में पास करके, हम अतिरिक्त मेमोरी आवंटन की आवश्यकता को समाप्त करते हुए, स्ट्रिंग पर कुशलतापूर्वक संचालन कर सकते हैं। 'std::string_view' डेटा को कॉपी किए बिना 'originalString' के अंतर्निहित वर्ण अनुक्रम का एक हल्का संदर्भ है।
यहाँ उत्पन्न आउटपुट है:
उदाहरण 2: लीगेसी कोड के साथ अंतरसंचालनीयता
C++ विकास के क्षेत्र में, नए और पुराने कोडबेस का निर्बाध एकीकरण अक्सर एक महत्वपूर्ण चिंता का विषय है। 'std::string_view' डेवलपर्स को पुराने फ़ंक्शंस के साथ सहजता से इंटरैक्ट करने की अनुमति देता है जो 'const char' पॉइंटर्स लौटाते हैं।
निम्नलिखित उदाहरण पर विचार करें जो इंटरऑपरेबिलिटी के लिए 'std::string_view' के व्यावहारिक उपयोग को प्रदर्शित करता है। यहां, हमारे पास 'legacyFunction()' नाम का एक लीगेसी फ़ंक्शन है जो 'const char' पॉइंटर लौटाता है:
#शामिल करें#शामिल <स्ट्रिंग_व्यू>
स्थिरांक चार * विरासत समारोह ( ) {
वापस करना 'विरासत स्ट्रिंग' ;
}
मुख्य प्रवेश बिंदु ( ) {
std::string_view लिगेसीStrView ( विरासत समारोह ( ) ) ;
std::cout << 'विरासत स्ट्रिंग दृश्य:' << लिगेसीस्ट्रव्यू << std::endl;
वापस करना 0 ;
}
हम 'legacyFunction()' नामक एक विरासत फ़ंक्शन को परिभाषित करके शुरू करते हैं जो एक 'const char' पॉइंटर लौटाता है जो एक स्ट्रिंग का प्रतिनिधित्व करता है जिसे 'Legacy String' के रूप में लेबल किया जाता है। इस विरासत डेटा को हमारे आधुनिक C++ प्रोग्राम में निर्बाध रूप से शामिल करने के लिए, हम 'std::string_view' का उपयोग करते हैं। मुख्य() फ़ंक्शन में, विशेष रूप से, हम 'legacyStrView' नामक 'std::string_view' का एक उदाहरण बनाते हैं और इसे लीगेसी फ़ंक्शन के परिणाम के साथ प्रारंभ करते हैं। यह इन्स्टेन्शियेशन हमें विरासती 'कॉन्स्ट चार' पॉइंटर को कुशलतापूर्वक समाहित करने और उसके साथ काम करने की अनुमति देता है।
परिणामस्वरूप, हम दक्षता और अनुकूलता दोनों को संरक्षित करते हुए, अनावश्यक डेटा प्रतिलिपि का सहारा लिए बिना विरासत स्ट्रिंग तक पहुंच और हेरफेर कर सकते हैं। कोड के अंतिम चरण में लीगेसी स्ट्रिंग दृश्य की सामग्री को मुद्रित करने के लिए 'std::cout' का उपयोग करना शामिल है।
निष्पादित आउटपुट है:
उदाहरण 3: बेहतर स्ट्रिंग लिटरल्स हैंडलिंग
C++ में स्ट्रिंग अक्षर पारंपरिक रूप से वर्णों की सारणी के रूप में दर्शाए जाते हैं। 'std::string_view' एक सुविधाजनक इंटरफ़ेस प्रदान करके स्ट्रिंग अक्षर के साथ काम करना सरल बनाता है। स्पष्ट रूपांतरणों की आवश्यकता के बिना अंतर्निहित वर्ण सरणी तक सीधी पहुंच की अनुमति देकर, 'std::string_view' स्ट्रिंग अक्षर पर संचालन को सुव्यवस्थित करता है।
#शामिल करें#शामिल <स्ट्रिंग_व्यू>
मुख्य प्रवेश बिंदु ( ) {
स्थिरांक चार * मेरा शाब्दिक = 'हैलो, स्ट्रिंग व्यू!' ;
std::string_view शाब्दिक दृश्य ( मेरा शाब्दिक ) ;
std::cout << 'पहला पात्र:' << शाब्दिक दृश्य [ 0 ] << std::endl;
आकार_टी स्थिति = शाब्दिक दृश्य.खोजें ( 'डोरी' ) ;
std::cout << 'सबस्ट्रिंग स्थिति:' << पद << std::endl;
वापस करना 0 ;
}
इस उदाहरण में, 'हैलो, स्ट्रिंग व्यू!' स्ट्रिंग शाब्दिक को 'myLiteral' सूचक को सौंपा गया है। 'std::string_view' की शुरूआत इसकी सामग्री की प्रतिलिपि बनाने की आवश्यकता के बिना इस स्ट्रिंग के अधिक कुशल प्रतिनिधित्व की सुविधा प्रदान करती है। 'लिटरलव्यू' ऑब्जेक्ट 'मायलिटरल' पॉइंटर का उपयोग करके बनाया गया है जो हमें अंतर्निहित वर्ण अनुक्रम को देखने और हेरफेर करने की अनुमति देता है।
'std::string_view' का उपयोग स्ट्रिंग के भीतर अलग-अलग वर्णों तक आसान पहुंच प्रदान करता है। कोड स्निपेट में, 'literalView[0]' स्ट्रिंग के पहले अक्षर को पुनर्प्राप्त और प्रिंट करता है, जो तत्वों तक पहुंचने की सरलता और प्रत्यक्षता को प्रदर्शित करता है। मूल स्ट्रिंग के भीतर 'स्ट्रिंग' सबस्ट्रिंग की स्थिति निर्धारित करने के लिए 'std::string_view' की 'ढूंढें' विधि का उपयोग किया जाता है।
उदाहरण 4: सबस्ट्रिंग निष्कर्षण
सबस्ट्रिंग निष्कर्षण के कार्य में सीमांकक की स्थिति जैसे निर्दिष्ट मानदंडों के आधार पर किसी दिए गए स्ट्रिंग के एक हिस्से को पुनः प्राप्त करना शामिल है। सबस्ट्रिंग को आसानी से निकालने की क्षमता 'std::string_view' की एक शक्तिशाली विशेषता है। एक ऐसे परिदृश्य पर विचार करें जहां हमें एक सीमांकक के आधार पर एक स्ट्रिंग के एक हिस्से को निकालने की आवश्यकता है:
#शामिल करें#शामिल <स्ट्रिंग_व्यू>
मुख्य प्रवेश बिंदु ( ) {
std::स्ट्रिंग फुलस्ट्रिंग = 'सेब-संतरा-केला' ;
size_t delimiterPos = FullString.find ( '-' ) ;
std::string_view सबस्ट्रिंग = फुलस्ट्रिंग.सबस्ट्र ( 0 , सीमांकक स्थिति ) ;
std::cout << 'निकाले गए सबस्ट्रिंग:' << सबस्ट्रिंग << std::endl;
वापस करना 0 ;
}
इस कोड स्निपेट में, हम एक मूल स्ट्रिंग, 'फुलस्ट्रिंग' की घोषणा के साथ शुरू करते हैं, जिसे 'सेब-नारंगी-केला' मान के साथ आरंभ किया जाता है। हमारा लक्ष्य सबस्ट्रिंग निष्कर्षण करना है। इसे प्राप्त करने के लिए, हम C++ मानक लाइब्रेरी द्वारा प्रदान किए गए 'खोज' फ़ंक्शन का उपयोग करते हैं।
एक बार जब हम 'delimiterPos' वेरिएबल में संग्रहीत 'फुलस्ट्रिंग' के भीतर डिलीमीटर की स्थिति की पहचान कर लेते हैं, तो हम वांछित सबस्ट्रिंग निकाल लेते हैं। 'सबस्ट्र' फ़ंक्शन को मूल स्ट्रिंग पर कॉल किया जाता है, जो शुरुआती स्थिति (0) और सबस्ट्रिंग की लंबाई निर्दिष्ट करता है जो कि वास्तव में डिलीमीटर की स्थिति है। इस ऑपरेशन के परिणामस्वरूप 'subString' नामक 'std::string_view' का निर्माण होता है जो शुरुआत से लेकर डिलीमीटर तक मूल स्ट्रिंग के हिस्से का प्रतिनिधित्व करता है।
उदाहरण 5: मेमोरी-कुशल डेटा संरचनाएँ
मेमोरी-कुशल डेटा संरचनाओं को डिजाइन करने में 'std::string_view' एक महत्वपूर्ण भूमिका निभाता है। स्ट्रिंग्स की कई प्रतियों को संग्रहीत करने के बजाय, डेटा संरचनाएं 'std::string_view' उदाहरणों को संग्रहीत कर सकती हैं, जिससे मेमोरी ओवरहेड कम हो जाता है।
#शामिल करें#शामिल <स्ट्रिंग_व्यू>
संरचना रिकार्ड {
std::string_view नाम;
पूर्ण आयु;
} ;
मुख्य प्रवेश बिंदु ( ) {
रिकार्ड व्यक्ति = { 'जॉन डो' , 30 } ;
std::cout << 'नाम: ' << व्यक्ति.नाम << ', आयु: ' << व्यक्ति.आयु << std::endl;
वापस करना 0 ;
}
इस कोड स्निपेट में, हम मेमोरी-कुशल डेटा संरचना के भीतर 'std::string_view' के उपयोग को दर्शाते हैं। हम एक 'रिकॉर्ड' संरचना को परिभाषित करते हैं जिसमें 'नाम' नामक एक 'std::string_view' सदस्य और 'आयु' नामक एक पूर्णांक सदस्य शामिल होता है। इस संदर्भ में 'std::string_view' का उपयोग हमें अतिरिक्त मेमोरी आवंटन की आवश्यकता के बिना एक स्ट्रिंग का हल्का प्रतिनिधित्व बनाने की अनुमति देता है।
'मुख्य' फ़ंक्शन में, हम 'व्यक्ति' नामक 'रिकॉर्ड' ऑब्जेक्ट को 'जॉन डो' नाम और 30 वर्ष की आयु के साथ इंस्टेंट करते हैं। 'std::string_view' सदस्य 'नाम' एक गैर-स्वामित्व वाले दृश्य के रूप में कार्य करता है नाम के अनुरूप वर्ण डेटा, स्ट्रिंग सामग्री को डुप्लिकेट करने की आवश्यकता को समाप्त करता है। 'std::cout << 'नाम:' << व्यक्ति.नाम << ', आयु: ' << व्यक्ति.आयु << std::endl;' स्टेटमेंट उस व्यक्ति का नाम और उम्र आउटपुट करता है जो 'रिकॉर्ड' ऑब्जेक्ट में संग्रहीत होता है।
निष्कर्ष
C++ विकास के निरंतर विकसित होते परिदृश्य में, 'std::string_view' प्रोग्रामर के टूलकिट में एक मूल्यवान अतिरिक्त के रूप में सामने आता है। इस आलेख में दर्शाए गए उदाहरण C++ प्रोग्रामिंग के दायरे में 'std::string_view' की अनुकूलनशीलता और उपयोगिता पर प्रकाश डालते हैं। कुशल स्ट्रिंग हेरफेर और विरासत कोड के साथ निर्बाध इंटरऑपरेबिलिटी से लेकर मेमोरी-कुशल डेटा संरचनाओं तक, 'std::string_view' उन डेवलपर्स के लिए मूल्यवान है जो विभिन्न परिदृश्यों में उन्नत प्रदर्शन और अनुकूलित कोड की तलाश कर रहे हैं। ये वास्तविक दुनिया के परिदृश्य दर्शाते हैं कि कैसे 'std::string_view' कोड को अनुकूलित कर सकता है, अनावश्यक मेमोरी ओवरहेड को कम कर सकता है और C++ अनुप्रयोगों की समग्र दक्षता में योगदान कर सकता है।