क्या स्ट्रिंग ऑपरेटर "+" इतना आसान है?

परिचय

एक स्ट्रिंग डेटा प्रकार संख्यात्मक (इंट, लॉन्ग, डबल) और लॉजिकल (बूलियन) वाले के साथ मौलिक डेटा प्रकारों में से एक है। आप शायद ही कम से कम एक उपयोगी कार्यक्रम की कल्पना कर सकते हैं जो इस प्रकार का उपयोग नहीं करता है।

.NET प्लेटफॉर्म पर, स्ट्रिंग प्रकार को एक अपरिवर्तनीय स्ट्रिंग वर्ग के रूप में प्रस्तुत किया जाता है। इसके अलावा, यह सीएलआर वातावरण में मजबूती से एकीकृत है और सी# कंपाइलर द्वारा भी समर्थित है।

यह लेख संयोजन के लिए समर्पित है - स्ट्रिंग्स पर किया जाने वाला एक ऑपरेशन जितनी बार अंकों पर जोड़ ऑपरेशन। आप सोच सकते हैं:"क्या कहना है?", आखिरकार, हम सभी स्ट्रिंग ऑपरेटर "+" के बारे में जानते हैं, लेकिन जैसा कि यह निकला, इसकी अपनी विशेषताएं हैं।

स्ट्रिंग ऑपरेटर "+" के लिए भाषा विनिर्देश

C# भाषा विनिर्देश स्ट्रिंग ऑपरेटर "+" के लिए तीन ओवरलोडिंग प्रदान करता है:

string operator + (string x, string y)

string operator + (string x, object y)

string operator + (object x, string y)

यदि स्ट्रिंग कॉन्सटेनेशन के ऑपरेंड में से एक NULL है, तो खाली स्ट्रिंग डाली जाती है। अन्यथा, कोई भी तर्क, जो एक स्ट्रिंग नहीं है, को ToString वर्चुअल विधि को कॉल करके एक स्ट्रिंग के रूप में दर्शाया जाता है। यदि ToString विधि NULL लौटाती है, तो एक खाली स्ट्रिंग डाली जाती है। यह ध्यान दिया जाना चाहिए कि विनिर्देश के अनुसार, इस ऑपरेशन को कभी भी NULL वापस नहीं करना चाहिए।

ऑपरेटर का विवरण काफी स्पष्ट है, हालांकि, यदि हम स्ट्रिंग वर्ग के कार्यान्वयन को देखते हैं, तो हमें केवल दो ऑपरेटरों "==" और "!=" की स्पष्ट परिभाषा मिलती है। एक वाजिब सवाल उठता है:स्ट्रिंग कॉन्सटेनेशन के दृश्यों के पीछे क्या होता है? कंपाइलर स्ट्रिंग ऑपरेटर “+” को कैसे हैंडल करता है?

इस प्रश्न का उत्तर इतना कठिन नहीं निकला। आइए स्थिर String.Concat विधि पर करीब से नज़र डालें। String.Concat विधि String वर्ग के एक या अधिक उदाहरणों को जोड़ती है या ऑब्जेक्ट के एक या अधिक उदाहरणों के String मानों के रूप में विचार करती है। इस विधि के निम्नलिखित ओवरलोडिंग हैं:

public static String Concat (String str0, String str1)

public static String Concat (String str0, String str1, String str2)

public static String Concat (String str0, String str1, String str2, String str3)

public static String Concat (params String[] values)

public static String Concat (IEnumerable <String> values)



public static String Concat (Object arg0)

public static String Concat (Object arg0, Object arg1)

public static String Concat (Object arg0, Object arg1, Object arg2)

public static String Concat (Object arg0, Object arg1, Object arg2, Object arg3, __arglist)



public static String Concat <T> (IEnumerable <T> values)

विवरण

मान लीजिए कि हमारे पास निम्नलिखित व्यंजक s =a + b है, जहां a और b तार हैं। कंपाइलर इसे कॉनकैट स्टैटिक मेथड की कॉल में बदल देता है, यानी

s = string.Concat (a, b)

सी# भाषा में किसी भी अन्य जोड़ ऑपरेशन की तरह स्ट्रिंग कॉन्सटेनेशन ऑपरेशन, लेफ्ट-एसोसिएटिव है।

दो पंक्तियों के साथ सब कुछ स्पष्ट है, लेकिन यदि अधिक पंक्तियां हों तो क्या होगा? व्यंजक s =a + b + c, संक्रिया की बाएँ-सहयोगिता को देखते हुए, इसके द्वारा प्रतिस्थापित किया जा सकता है:

s = string.Concat(string.Concat (a, b), c)

हालांकि, ओवरलोडिंग को देखते हुए जिसमें तीन तर्क होते हैं, इसे इसमें बदल दिया जाएगा:

s = string.Concat (a, b, c)

इसी तरह की स्थिति चार तारों के संयोजन के साथ है। 5 या अधिक स्ट्रिंग्स को जोड़ने के लिए, हमारे पास स्ट्रिंग है। कॉनकैट ओवरलोडिंग (पैरा स्ट्रिंग []), इसलिए किसी सरणी के लिए मेमोरी आवंटन से जुड़े ओवरहेड को ध्यान में रखना आवश्यक है।

यह भी ध्यान दिया जाना चाहिए कि स्ट्रिंग कॉन्सटेनेशन ऑपरेटर पूरी तरह से सहयोगी है :इससे कोई फर्क नहीं पड़ता कि हम किस क्रम में तार जोड़ते हैं, इसलिए अभिव्यक्ति s =a + (b + c), स्पष्ट रूप से संकेतित निष्पादन की प्राथमिकता के बावजूद, निम्नानुसार संसाधित किया जाएगा

s = (a + b) + c = string.Concat (a, b, c)

अपेक्षा के बजाय:

s = string.Concat (a, string.Concat (b, c))

इस प्रकार, पूर्वगामी का सारांश:स्ट्रिंग संयोजन संचालन हमेशा बाएं से दाएं दर्शाया जाता है और स्थिर String.Concat विधि को कॉल करता है।

शाब्दिक स्ट्रिंग्स के लिए कंपाइलर को ऑप्टिमाइज़ करना

C# कंपाइलर में शाब्दिक स्ट्रिंग्स से संबंधित अनुकूलन हैं। उदाहरण के लिए, व्यंजक s ="a" + "b" + c, जिसे "+" ऑपरेटर की बाईं-सहयोगिता दी गई है, s =("a" + "b") + c के बराबर है

s = string.Concat ("ab", c)

अभिव्यक्ति s =c + "a" + "b", संयोजन के संचालन की बाईं-सहयोगिता के बावजूद (s =(c + "a") + "b") को

s = string.Concat (c, "ab")

सामान्य तौर पर, शाब्दिक की स्थिति कोई मायने नहीं रखती है, कंपाइलर जो कुछ भी कर सकता है उसे जोड़ता है, और उसके बाद ही कॉनकैट विधि के उपयुक्त अधिभार का चयन करने का प्रयास करता है। व्यंजक s =a + “b” + “c” + d को

s = string.Concat (a, "bc", d)

खाली और NULL स्ट्रिंग्स से जुड़े ऑप्टिमाइज़ेशन का भी उल्लेख किया जाना चाहिए। संकलक जानता है कि एक खाली स्टिंग जोड़ने से संयोजन का परिणाम प्रभावित नहीं होता है, इसलिए अभिव्यक्ति s =a + "" + b को

s = string.Concat (a, b),

अपेक्षित के बजाय

s = string.Concat (a, "", b)

इसी तरह, कॉन्स स्ट्रिंग के साथ, जिसका मान NULL है, हमारे पास है:

const string nullStr = null;

s = a + nullStr + b;

s = string.Concat (a, b)

व्यंजक s =a + nullStr को s =a में बदल दिया जाता है ?? "", यदि a एक स्ट्रिंग है, और स्ट्रिंग की कॉल है। Concat विधि (a), यदि a एक स्ट्रिंग नहीं है, उदाहरण के लिए, s =17 + nullStr, तो इसे s =string.Concat (17) में बदल दिया जाता है। ।

शाब्दिक प्रसंस्करण के अनुकूलन और स्ट्रिंग ऑपरेटर "+" की बाईं-सहयोगिता से जुड़ी एक दिलचस्प विशेषता।

आइए व्यंजक पर विचार करें:

var s1 = 17 + 17 + "abc";

वाम-सहयोगिता को ध्यान में रखते हुए, यह

var s1 = (17 + 17) + "abc"; // сalling the string.Concat method (34, "abc")

नतीजतन, संकलन समय पर, अंक जोड़े जाते हैं, जिससे परिणाम 34abc होगा।

दूसरी ओर, व्यंजक

var s2 = "abc" + 17 + 17;

के बराबर है

var s2 = ( "abc" + 17) + 17; // calling the string.Concat method ("abc", 17, 17)

परिणाम abc1717 होगा।

तो, आप वहां जाएं, एक ही कॉन्सटेनेशन ऑपरेटर अलग-अलग परिणाम देता है।

String.Concat VS StringBuilder.Append

इस तुलना के बारे में कुछ शब्द कहना आवश्यक है। आइए निम्नलिखित कोड पर विचार करें:

string name = "Timur";

string surname = "Guev";

string patronymic = "Ahsarbecovich";

string fio = surname + name + patronymic;

इसे StringBuilder का उपयोग करके कोड से बदला जा सकता है:

var sb = new StringBuilder ();

sb.Append (surname);

sb.Append (name);

sb.Append (patronymic);

string fio = sb.ToString ();

हालांकि, इस मामले में, स्ट्रिंगबिल्डर का उपयोग करने से हमें शायद ही कोई लाभ मिलेगा। इस तथ्य के अलावा कि कोड कम पठनीय हो गया है, यह कमोबेश प्रभावी हो गया है, क्योंकि कॉनकैट पद्धति का कार्यान्वयन परिणामी स्ट्रिंग की लंबाई की गणना करता है और केवल एक बार मेमोरी आवंटित करता है, स्ट्रिंगबिल्डर के विपरीत जो लंबाई के बारे में कुछ नहीं जानता है परिणामी स्ट्रिंग का।

3 स्ट्रिंग्स के लिए Concat विधि का कार्यान्वयन:

public static string Concat (string str0, string str1, string str2)

{

if (str0 == null && str1 == null && str2 == null)

return string.Empty;

if (str0 == null)

str0 = string.Empty;

if (str1 == null)

str1 = string.Empty;

if (str2 == null)

str2 = string.Empty;

string dest = string.FastAllocateString (str0.Length + str1.Length + str2.Length); // Allocate memory for strings

string.FillStringChecked (dest, 0, str0); /

string.FillStringChecked (dest, str0.Length, str1);

string.FillStringChecked (dest, str0.Length + str1.Length, str2);

return dest;

}

जावा में ऑपरेटर “+”

जावा में स्ट्रिंग ऑपरेटर "+" के बारे में कुछ शब्द। हालाँकि मैं जावा में प्रोग्राम नहीं करता, फिर भी मुझे इसमें दिलचस्पी है कि यह वहाँ कैसे काम करता है। जावा कंपाइलर "+" ऑपरेटर को ऑप्टिमाइज़ करता है ताकि वह StringBuilder क्लास का उपयोग करे और एपेंड विधि को कॉल करे।

पिछला कोड इसमें बदल दिया गया है

String fio = new StringBuilder(String.valueOf(surname)).append(name).append (patronymic).ToString()

यह ध्यान देने योग्य है कि उन्होंने जानबूझकर सी # में इस तरह के अनुकूलन से इनकार कर दिया, एरिक लिपर्ट के पास इस विषय पर एक पोस्ट है। मुद्दा यह है कि ऐसा अनुकूलन अनुकूलन नहीं है, यह कोड पुनर्लेखन है। इसके अलावा, C# भाषा के रचनाकारों का मानना ​​है कि डेवलपर्स को String वर्ग के साथ काम करने के पहलुओं से परिचित होना चाहिए और यदि आवश्यक हो, तो StringBuilder पर स्विच करें।

वैसे, एरिक लिपर्ट ही थे जिन्होंने स्ट्रिंग्स के संयोजन से जुड़े C# कंपाइलर के अनुकूलन पर काम किया था।

निष्कर्ष

शायद, पहली नज़र में, यह अजीब लग सकता है कि स्ट्रिंग वर्ग ऑपरेटर "+" को तब तक परिभाषित नहीं करता जब तक हम एक बड़े कोड खंड की दृश्यता से संबंधित कंपाइलर की अनुकूलन क्षमता के बारे में नहीं सोचते। उदाहरण के लिए, यदि स्ट्रिंग वर्ग में "+" ऑपरेटर को परिभाषित किया गया था, तो अभिव्यक्ति s =a + b + c + d दो मध्यवर्ती स्ट्रिंग्स के निर्माण की ओर ले जाएगा, स्ट्रिंग की एक कॉल। कॉनकैट (ए, बी, सी, डी) विधि संयोजन को अधिक प्रभावी ढंग से करने की अनुमति देती है।