क्या कोई मुझे नीचे उदाहरण के लिए मेमोरी में बनाए गए स्ट्रिंग इंस्टेंस की कुल संख्या बता सकता है? संक्षिप्त विवरण की बहुत सराहना की जाएगी।
मेरा कोड:
String A = "1" + "2" + "3" ; /* total number of strings in memory = ?? */
String B = "1" + "2" + "1" ; /* total number of strings in memory = ?? */
string one = "1";
string two = "2";
string three = "3";
String C = one + two + three; /* total number of strings in memory = ?? */
String D = one + two + one; /* total number of strings in memory = ?? */
उत्तर:
उत्तर № 1 के लिए 4वहाँ से स्ट्रिंग संघनन पर सी # प्रलेखन:
जब आप + ऑपरेटर का उपयोग करके स्ट्रिंग शाब्दिक या स्ट्रिंग स्थिरांक को बदलते हैं, तो संकलक एक स्ट्रिंग बनाता है। कोई रन टाइम कॉन्सेप्ट नहीं होता है।
इसका अर्थ है कि आपके संघटन केवल एक स्ट्रिंग बनाते हैं, इसलिए कुल मिलाकर आपके उदाहरण में स्मृति में 7 तार उत्पन्न होते हैं:
String A = "1" + "2" + "3" ; // 1 (concatenation of literals)
String B = "1" + "2" + "1" ; // 1 (concatenation of literals)
string one = "1"; // 1
string two = "2"; // 1
string three = "3"; // 1
String C = one + two + three; // 1 (concatenation of string constants)
String D = one + two + one; // 1 (concatenation of string constants)
// = 7 strings in total
हालांकि, अगर एक पाश में संघात करते हैं, तो अधिक तार उत्पन्न होते हैं, उदाहरण
for word in text:
result_string += word // Bad! Creates a new string in each iteration
इस मामले में इसका उपयोग करना बेहतर है StringBuilder.append:
System.Text.StringBuilder builder = new System.Text.StringBuilder();
for word in text:
builder.Append(word) // Good! Just appends to the string builder
जवाब के लिए 3 № 2
आइए DASM में IL का कोड देखें
.method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
// Code size 54 (0x36)
.maxstack 3
.locals init ([0] string A,
[1] string B,
[2] string one,
[3] string two,
[4] string three,
[5] string C,
[6] string D)
IL_0000: nop
IL_0001: ldstr "123"
IL_0006: stloc.0
IL_0007: ldstr "121"
IL_000c: stloc.1
IL_000d: ldstr "1"
IL_0012: stloc.2
IL_0013: ldstr "2"
IL_0018: stloc.3
IL_0019: ldstr "3"
IL_001e: stloc.s three
IL_0020: ldloc.2
IL_0021: ldloc.3
IL_0022: ldloc.s three
IL_0024: call string [mscorlib]System.String::Concat(string,
string,
string)
IL_0029: stloc.s C
IL_002b: ldloc.2
IL_002c: ldloc.3
IL_002d: ldloc.2
IL_002e: call string [mscorlib]System.String::Concat(string,
string,
string)
IL_0033: stloc.s D
IL_0035: ret
} // end of method Program::Main
जैसा कि आप देख सकते हैं, 5 स्ट्रिंग स्थिरांक हैं
"123", "121", "1", "2", "3"
और संघटन द्वारा प्राप्त दो तार कुल 7।
हालांकि ए और सी (बी और डी) तार समान हैं, लेकिन वे स्मृति में विभिन्न उदाहरण हैं।
से अर्घ्य सी।
यदि हम असुरक्षित कोड लागू करते हैं और चर A के मान को बदलते हैं:
Console.WriteLine(A + " " + C);
fixed (char* p = A)
{
p[1] = "x";
}
Console.WriteLine(A + " " + C);
हम निम्नलिखित उत्पादन प्राप्त:
123 123
1x3 123
जैसा कि आप देख सकते हैं, केवल चर A बदल गया है, लेकिन C चर ने अपना मान बरकरार रखा है। यह साबित करता है कि वे अलग प्रतियां हैं।
हालाँकि, अगर हम इसे लिखते हैं:
String A = "1" + "2" + "3";
String C = "123";
उपरोक्त असुरक्षित कोड को निष्पादित करने के बाद हमें निम्नलिखित मिलते हैं:
123 123
1x3 1x3
यही है, इस मामले में, चर ए और सी स्ट्रिंग के एक ही उदाहरण के लिए एक संदर्भ रखता है।
पहले तो मैंने गलत जवाब लिखा, क्योंकि मुझे लगा कि कंपाइलर इतना स्मार्ट है कि कंपाइल-टाइम पर समझ सकता है String C = one + two + three; कॉन्स्टेंट को समेटता है और एक ही स्ट्रिंग पर संदर्भ बनाएगा।