सामग्री पर जाएँ
Topos Uranos
हिन्दी

स्ट्रिंग

सारांश

टेक्स्ट किसी प्रोग्राम का सबसे आम डेटा है: नाम, संदेश, किसी फ़ाइल की पंक्तियाँ, किसी उपयोगकर्ता की कमांडें। यह पाठ उसे वैसा ही मानता है जैसा वह C++ के लिए है, यानी अपनी संक्रियाओं वाला वर्णों का एक अनुक्रम। यह std::string प्रस्तुत करता है, जिसे टेक्स्ट के काम के लिए बने char के वेक्टर की तरह बनाया, जोड़ा, तुलना किया और ट्रैवर्स किया जाता है; उसकी खोजने और निकालने की संक्रियाएँ (find, substr, starts_with, contains) और मान std::string::npos, जिससे find बताता है कि उसे कुछ नहीं मिला; std::string_view, वह व्यू जो किसी टेक्स्ट की प्रति बनाए बिना उसे देखता है, और वह शर्त जिस पर वह निर्भर है: कि देखा जा रहा टेक्स्ट मौजूद रहे। पाठ के अंत में C स्ट्रिंग आती हैं, दूसरों का कोड पढ़ने के लिए, और वह क्रम जिसमें C++ शब्दों की तुलना करता है और उन्हें क्रमबद्ध करता है।

अधिगम उद्देश्य

  1. टेक्स्ट की समस्याएँ हल करने के लिए std::string की संक्रियाओं (size, +, find, substr, starts_with, contains) का उपयोग करना।
  2. find के परिणाम की व्याख्या करना और उसकी तुलना std::string::npos से करना, और यह अनुमान लगाना कि उसे कोई साधारण संख्या मानने पर क्या होता है।
  3. किसी फ़ंक्शन में टेक्स्ट को std::string_view के रूप में लेना और एक उदाहरण से समझाना कि कोई व्यू उस स्ट्रिंग से अधिक समय तक क्यों नहीं जीना चाहिए जिसे वह देखता है।
  4. C स्ट्रिंग वाला कोड पढ़ना और std::string से उनके अंतर समझाना: नल टर्मिनेटर, निश्चित आकार, और दो लिटरलों का योग, जो कंपाइल नहीं होता।

स्ट्रिंग std::string

बनाना, जोड़ना, ट्रैवर्स करना

पाठ वर्ण, बूलियन, रूपांतरण और स्थिरांक ने वर्ण, char, को एक छोटी संख्या के रूप में प्रस्तुत किया था जिसे एक तालिका अक्षर में बदलती है। टेक्स्ट वर्णों का एक क्रम है; यदि ऐसा है, तो उसे std::vector<char> में रखा जा सकता है, और पाठ वेक्टर ने अनुक्रमों के बारे में जो सिखाया, वह उस पर भी लागू होगा। परंतु टेक्स्ट से ऐसी संक्रियाएँ माँगी जाती हैं जो किसी भी अनुक्रम से नहीं माँगी जातीं: उसके साथ दूसरा टेक्स्ट चिपकाना, उसमें कोई शब्द खोजना, उसका एक हिस्सा निकालना, उसे एक बार में लिखना। इससे एक अपना प्रकार निकलता है, स्ट्रिंग, std::string, हेडर <string> से: टेक्स्ट के काम के लिए बना char का एक वेक्टर।

C++ प्रोग्राम
#include <format>#include <print>#include <string>​int main(){    const std::string first{"Ada"};    std::string greeting{"Hola, " + first};    greeting += '.';    std::println("{} ({} वर्ण)", greeting, greeting.size());    std::println("पहला “{}”, आखिरी “{}”", greeting[0], greeting.back());    int spaces{0};    for (const char c : greeting) {        if (c == ' ') {            ++spaces;        }    }    std::println("रिक्त स्थान: {}", spaces);    const std::string code{std::format("{}-{:03}", "MAT", 7)};    std::println("{} {}", code, code == "MAT-007");}
आउटपुट
Hola, Ada. (10 वर्ण)पहला “H”, आखिरी “.”रिक्त स्थान: 1MAT-007 true

पंक्ति 7 एक लिटरल से एक स्ट्रिंग बनाती है। पंक्ति 8 उसे स्पेनिश अभिवादन “Hola, ” (“नमस्ते, ”) के साथ जोड़ती है: किसी स्ट्रिंग और लिटरल के बीच संक्रियक + एक नई स्ट्रिंग बनाता है जिसमें दोनों के वर्ण एक के बाद एक होते हैं। पंक्ति 9 अंत में += से एक वर्ण जोड़ती है, जो एक स्ट्रिंग या लिटरल भी स्वीकार करता है। बाकी वही है जो वेक्टरों के बारे में पहले से ज्ञात था: size() वर्ण गिनता है (10, क्योंकि अल्पविराम, रिक्त स्थान और पूर्णविराम भी वर्ण हैं), greeting[0] पहला है और back() आखिरी, और पंक्ति 13 से 17 तक का लूप पाठ लूप के रेंज वाले रूप से स्ट्रिंग को वर्ण-दर-वर्ण ट्रैवर्स करता है। वेक्टर की तरह, स्ट्रिंग में push_back, pop_back और empty भी हैं, और GCC 15 की लाइब्रेरी, जब ऑप्टिमाइज़ेशन नहीं होता, operator[] में उसके इंडेक्स जाँचती है (ऑप्टिमाइज़ेशन के साथ यह जाँच गायब हो जाती है)।

आखिरी दो पंक्तियाँ वह पूरा करती हैं जिसकी घोषणा पाठ फ़ंक्शनों से डिज़ाइन ने की थी। std::format, जो <format> से आता है, वही प्लेसहोल्डर लेता है जो std::println लेता है, उन्हीं फ़ॉर्मैट विनिर्देशों के साथ ({:03} तीन अंकों तक शून्य भरता है), पर परिणाम लिखने के बजाय उसे स्ट्रिंग के रूप में लौटाता है: यही वह तरीका है जिससे ऐसा टेक्स्ट बनाया जाता है जिसे बाद में सहेजा, तुलना किया या किसी फ़ंक्शन को दिया जाता है। और == दो स्ट्रिंगों की तुलना उनकी सामग्री से करता है: वे बराबर हैं यदि उनका आकार समान है और उनमें समान वर्ण समान क्रम में हैं। इसलिए code == "MAT-007" का मान true है, भले ही बाईं ओर का टेक्स्ट टुकड़ों में बनाया गया हो और दाईं ओर का एक लिटरल हो।

तुलना

== और != के अलावा, स्ट्रिंगें <, <=, > और >= भी स्वीकार करती हैं, जो उनकी तुलना शब्दकोशीय क्रम में करते हैं, यानी शब्दकोश के क्रम में: दोनों को साथ-साथ ट्रैवर्स किया जाता है, और पहली स्थिति में जहाँ वे भिन्न होती हैं, छोटा वर्ण निर्णय करता है; यदि कोई एक बिना किसी अंतर के पहले समाप्त हो जाए, तो छोटी स्ट्रिंग छोटी है। इस तरह, स्पेनिश शब्द “casa” शब्द “cosa” से छोटा है, क्योंकि दूसरी स्थिति में 'a' < 'o' है, और “mar” शब्द “marea” से छोटा है, क्योंकि पहला दूसरे का उपसर्ग है। संक्रियक स्ट्रिंगों की तुलना करते हैं: उद्धरण चिह्नों में लिखे दो लिटरलों के बीच वे कुछ और तुलना करते हैं, क्योंकि लिटरल std::string नहीं बल्कि एक ऐरे है, जैसा C स्ट्रिंग वाले अनुभाग में दिखेगा। कौन-सा वर्ण “छोटा” है, यह उसका कोड तय करता है, वर्णमाला नहीं; पाठ का अंतिम अनुभाग दिखाता है कि इससे क्या निकलता है।